Termination w.r.t. Q proof of TRS/Cimemucrl1.trs

Termination w.r.t. Q of the following Term Rewriting System could be proven:

Q restricted rewrite system:
The TRS R consists of the following rules:

or₂(T, T) -> T
or₂(F, T) -> T
or₂(T, F) -> T
or₂(F, F) -> F
and₂(T, B) -> B
and₂(B, T) -> B
and₂(F, B) -> F
and₂(B, F) -> F
imp₂(T, B) -> B
imp₂(F, B) -> T
not₁(T) -> F
not₁(F) -> T
if₃(T, B1, B2) -> B1
if₃(F, B1, B2) -> B2
eq₂(T, T) -> T
eq₂(F, F) -> T
eq₂(T, F) -> F
eq₂(F, T) -> F
eqt₂(nil, undefined) -> F
eqt₂(nil, pid₁(N2)) -> F
eqt₂(nil, int₁(N2)) -> F
eqt₂(nil, cons₂(H2, T2)) -> F
eqt₂(nil, tuple₂(H2, T2)) -> F
eqt₂(nil, tuplenil₁(H2)) -> F
eqt₂(a, nil) -> F
eqt₂(a, a) -> T
eqt₂(a, excl) -> F
eqt₂(a, false) -> F
eqt₂(a, lock) -> F
eqt₂(a, locker) -> F
eqt₂(a, mcrlrecord) -> F
eqt₂(a, ok) -> F
eqt₂(a, pending) -> F
eqt₂(a, release) -> F
eqt₂(a, request) -> F
eqt₂(a, resource) -> F
eqt₂(a, tag) -> F
eqt₂(a, true) -> F
eqt₂(a, undefined) -> F
eqt₂(a, pid₁(N2)) -> F
eqt₂(a, int₁(N2)) -> F
eqt₂(a, cons₂(H2, T2)) -> F
eqt₂(a, tuple₂(H2, T2)) -> F
eqt₂(a, tuplenil₁(H2)) -> F
eqt₂(excl, nil) -> F
eqt₂(excl, a) -> F
eqt₂(excl, excl) -> T
eqt₂(excl, false) -> F
eqt₂(excl, lock) -> F
eqt₂(excl, locker) -> F
eqt₂(excl, mcrlrecord) -> F
eqt₂(excl, ok) -> F
eqt₂(excl, pending) -> F
eqt₂(excl, release) -> F
eqt₂(excl, request) -> F
eqt₂(excl, resource) -> F
eqt₂(excl, tag) -> F
eqt₂(excl, true) -> F
eqt₂(excl, undefined) -> F
eqt₂(excl, pid₁(N2)) -> F
eqt₂(excl, eqt₂(false, int₁(N2))) -> F
eqt₂(false, cons₂(H2, T2)) -> F
eqt₂(false, tuple₂(H2, T2)) -> F
eqt₂(false, tuplenil₁(H2)) -> F
eqt₂(lock, nil) -> F
eqt₂(lock, a) -> F
eqt₂(lock, excl) -> F
eqt₂(lock, false) -> F
eqt₂(lock, lock) -> T
eqt₂(lock, locker) -> F
eqt₂(lock, mcrlrecord) -> F
eqt₂(lock, ok) -> F
eqt₂(lock, pending) -> F
eqt₂(lock, release) -> F
eqt₂(lock, request) -> F
eqt₂(lock, resource) -> F
eqt₂(lock, tag) -> F
eqt₂(lock, true) -> F
eqt₂(lock, undefined) -> F
eqt₂(lock, pid₁(N2)) -> F
eqt₂(lock, int₁(N2)) -> F
eqt₂(lock, cons₂(H2, T2)) -> F
eqt₂(lock, tuple₂(H2, T2)) -> F
eqt₂(lock, tuplenil₁(H2)) -> F
eqt₂(locker, nil) -> F
eqt₂(locker, a) -> F
eqt₂(locker, excl) -> F
eqt₂(locker, false) -> F
eqt₂(locker, lock) -> F
eqt₂(locker, locker) -> T
eqt₂(locker, mcrlrecord) -> F
eqt₂(locker, ok) -> F
eqt₂(locker, pending) -> F
eqt₂(locker, release) -> F
eqt₂(locker, request) -> F
eqt₂(locker, resource) -> F
eqt₂(locker, tag) -> F
eqt₂(locker, true) -> F
eqt₂(locker, undefined) -> F
eqt₂(locker, pid₁(N2)) -> F
eqt₂(locker, int₁(N2)) -> F
eqt₂(locker, cons₂(H2, T2)) -> F
eqt₂(locker, tuple₂(H2, T2)) -> F
eqt₂(locker, tuplenil₁(H2)) -> F
eqt₂(mcrlrecord, nil) -> F
eqt₂(mcrlrecord, a) -> F
eqt₂(mcrlrecord, excl) -> F
eqt₂(mcrlrecord, false) -> F
eqt₂(mcrlrecord, lock) -> F
eqt₂(mcrlrecord, locker) -> F
eqt₂(mcrlrecord, mcrlrecord) -> T
eqt₂(mcrlrecord, ok) -> F
eqt₂(mcrlrecord, pending) -> F
eqt₂(mcrlrecord, release) -> F
eqt₂(mcrlrecord, request) -> F
eqt₂(mcrlrecord, resource) -> F
eqt₂(ok, resource) -> F
eqt₂(ok, tag) -> F
eqt₂(ok, true) -> F
eqt₂(ok, undefined) -> F
eqt₂(ok, pid₁(N2)) -> F
eqt₂(ok, int₁(N2)) -> F
eqt₂(ok, cons₂(H2, T2)) -> F
eqt₂(ok, tuple₂(H2, T2)) -> F
eqt₂(ok, tuplenil₁(H2)) -> F
eqt₂(pending, nil) -> F
eqt₂(pending, a) -> F
eqt₂(pending, excl) -> F
eqt₂(pending, false) -> F
eqt₂(pending, lock) -> F
eqt₂(pending, locker) -> F
eqt₂(pending, mcrlrecord) -> F
eqt₂(pending, ok) -> F
eqt₂(pending, pending) -> T
eqt₂(pending, release) -> F
eqt₂(pending, request) -> F
eqt₂(pending, resource) -> F
eqt₂(pending, tag) -> F
eqt₂(pending, true) -> F
eqt₂(pending, undefined) -> F
eqt₂(pending, pid₁(N2)) -> F
eqt₂(pending, int₁(N2)) -> F
eqt₂(pending, cons₂(H2, T2)) -> F
eqt₂(pending, tuple₂(H2, T2)) -> F
eqt₂(pending, tuplenil₁(H2)) -> F
eqt₂(release, nil) -> F
eqt₂(release, a) -> F
eqt₂(release, excl) -> F
eqt₂(release, false) -> F
eqt₂(release, lock) -> F
eqt₂(release, locker) -> F
eqt₂(release, mcrlrecord) -> F
eqt₂(release, ok) -> F
eqt₂(request, mcrlrecord) -> F
eqt₂(request, ok) -> F
eqt₂(request, pending) -> F
eqt₂(request, release) -> F
eqt₂(request, request) -> T
eqt₂(request, resource) -> F
eqt₂(request, tag) -> F
eqt₂(request, true) -> F
eqt₂(request, undefined) -> F
eqt₂(request, pid₁(N2)) -> F
eqt₂(request, int₁(N2)) -> F
eqt₂(request, cons₂(H2, T2)) -> F
eqt₂(request, tuple₂(H2, T2)) -> F
eqt₂(request, tuplenil₁(H2)) -> F
eqt₂(resource, nil) -> F
eqt₂(resource, a) -> F
eqt₂(resource, excl) -> F
eqt₂(resource, false) -> F
eqt₂(resource, lock) -> F
eqt₂(resource, locker) -> F
eqt₂(resource, mcrlrecord) -> F
eqt₂(resource, ok) -> F
eqt₂(resource, pending) -> F
eqt₂(resource, release) -> F
eqt₂(resource, request) -> F
eqt₂(resource, resource) -> T
eqt₂(resource, tag) -> F
eqt₂(resource, true) -> F
eqt₂(resource, undefined) -> F
eqt₂(resource, pid₁(N2)) -> F
eqt₂(resource, int₁(N2)) -> F
eqt₂(resource, cons₂(H2, T2)) -> F
eqt₂(resource, tuple₂(H2, T2)) -> F
eqt₂(resource, tuplenil₁(H2)) -> F
eqt₂(tag, nil) -> F
eqt₂(tag, a) -> F
eqt₂(tag, excl) -> F
eqt₂(tag, false) -> F
eqt₂(tag, lock) -> F
eqt₂(tag, locker) -> F
eqt₂(tag, mcrlrecord) -> F
eqt₂(tag, ok) -> F
eqt₂(tag, pending) -> F
eqt₂(tag, release) -> F
eqt₂(tag, request) -> F
eqt₂(tag, resource) -> F
eqt₂(tag, tag) -> T
eqt₂(tag, true) -> F
eqt₂(tag, undefined) -> F
eqt₂(tag, pid₁(N2)) -> F
eqt₂(tag, int₁(N2)) -> F
eqt₂(tag, cons₂(H2, T2)) -> F
eqt₂(tag, tuple₂(H2, T2)) -> F
eqt₂(tag, tuplenil₁(H2)) -> F
eqt₂(true, nil) -> F
eqt₂(true, a) -> F
eqt₂(true, excl) -> F
eqt₂(true, false) -> F
eqt₂(true, lock) -> F
eqt₂(true, locker) -> F
eqt₂(true, mcrlrecord) -> F
eqt₂(true, ok) -> F
eqt₂(true, pending) -> F
eqt₂(true, release) -> F
eqt₂(true, request) -> F
eqt₂(true, resource) -> F
eqt₂(true, tag) -> F
eqt₂(true, true) -> T
eqt₂(true, undefined) -> F
eqt₂(true, pid₁(N2)) -> F
eqt₂(true, int₁(N2)) -> F
eqt₂(true, cons₂(H2, T2)) -> F
eqt₂(true, tuple₂(H2, T2)) -> F
eqt₂(true, tuplenil₁(H2)) -> F
eqt₂(undefined, nil) -> F
eqt₂(undefined, a) -> F
eqt₂(undefined, tuplenil₁(H2)) -> F
eqt₂(pid₁(N1), nil) -> F
eqt₂(pid₁(N1), a) -> F
eqt₂(pid₁(N1), excl) -> F
eqt₂(pid₁(N1), false) -> F
eqt₂(pid₁(N1), lock) -> F
eqt₂(pid₁(N1), locker) -> F
eqt₂(pid₁(N1), mcrlrecord) -> F
eqt₂(pid₁(N1), ok) -> F
eqt₂(pid₁(N1), pending) -> F
eqt₂(pid₁(N1), release) -> F
eqt₂(pid₁(N1), request) -> F
eqt₂(pid₁(N1), resource) -> F
eqt₂(pid₁(N1), tag) -> F
eqt₂(pid₁(N1), true) -> F
eqt₂(pid₁(N1), undefined) -> F
eqt₂(pid₁(N1), pid₁(N2)) -> eqt₂(N1, N2)
eqt₂(pid₁(N1), int₁(N2)) -> F
eqt₂(pid₁(N1), cons₂(H2, T2)) -> F
eqt₂(pid₁(N1), tuple₂(H2, T2)) -> F
eqt₂(pid₁(N1), tuplenil₁(H2)) -> F
eqt₂(int₁(N1), nil) -> F
eqt₂(int₁(N1), a) -> F
eqt₂(int₁(N1), excl) -> F
eqt₂(int₁(N1), false) -> F
eqt₂(int₁(N1), lock) -> F
eqt₂(int₁(N1), locker) -> F
eqt₂(int₁(N1), mcrlrecord) -> F
eqt₂(int₁(N1), ok) -> F
eqt₂(int₁(N1), pending) -> F
eqt₂(int₁(N1), release) -> F
eqt₂(int₁(N1), request) -> F
eqt₂(int₁(N1), resource) -> F
eqt₂(int₁(N1), tag) -> F
eqt₂(int₁(N1), true) -> F
eqt₂(int₁(N1), undefined) -> F
eqt₂(cons₂(H1, T1), resource) -> F
eqt₂(cons₂(H1, T1), tag) -> F
eqt₂(cons₂(H1, T1), true) -> F
eqt₂(cons₂(H1, T1), undefined) -> F
eqt₂(cons₂(H1, T1), pid₁(N2)) -> F
eqt₂(cons₂(H1, T1), int₁(N2)) -> F
eqt₂(cons₂(H1, T1), cons₂(H2, T2)) -> and₂(eqt₂(H1, H2), eqt₂(T1, T2))
eqt₂(cons₂(H1, T1), tuple₂(H2, T2)) -> F
eqt₂(cons₂(H1, T1), tuplenil₁(H2)) -> F
eqt₂(tuple₂(H1, T1), nil) -> F
eqt₂(tuple₂(H1, T1), a) -> F
eqt₂(tuple₂(H1, T1), excl) -> F
eqt₂(tuple₂(H1, T1), false) -> F
eqt₂(tuple₂(H1, T1), lock) -> F
eqt₂(tuple₂(H1, T1), locker) -> F
eqt₂(tuple₂(H1, T1), mcrlrecord) -> F
eqt₂(tuple₂(H1, T1), ok) -> F
eqt₂(tuple₂(H1, T1), pending) -> F
eqt₂(tuple₂(H1, T1), release) -> F
eqt₂(tuple₂(H1, T1), request) -> F
eqt₂(tuple₂(H1, T1), resource) -> F
eqt₂(tuple₂(H1, T1), tag) -> F
eqt₂(tuple₂(H1, T1), true) -> F
eqt₂(tuple₂(H1, T1), undefined) -> F
eqt₂(tuple₂(H1, T1), pid₁(N2)) -> F
eqt₂(tuple₂(H1, T1), int₁(N2)) -> F
eqt₂(tuple₂(H1, T1), cons₂(H2, T2)) -> F
eqt₂(tuple₂(H1, T1), tuple₂(H2, T2)) -> and₂(eqt₂(H1, H2), eqt₂(T1, T2))
eqt₂(tuple₂(H1, T1), tuplenil₁(H2)) -> F
eqt₂(tuplenil₁(H1), nil) -> F
eqt₂(tuplenil₁(H1), a) -> F
eqt₂(tuplenil₁(H1), excl) -> F
eqt₂(tuplenil₁(H1), false) -> F
eqt₂(tuplenil₁(H1), lock) -> F
eqt₂(tuplenil₁(H1), locker) -> F
eqt₂(tuplenil₁(H1), mcrlrecord) -> F
eqt₂(tuplenil₁(H1), ok) -> F
eqt₂(tuplenil₁(H1), pending) -> F
eqt₂(tuplenil₁(H1), release) -> F
eqt₂(tuplenil₁(H1), request) -> F
eqt₂(tuplenil₁(H1), resource) -> F
eqt₂(tuplenil₁(H1), tag) -> F
eqt₂(tuplenil₁(H1), true) -> F
eqt₂(tuplenil₁(H1), undefined) -> F
eqt₂(tuplenil₁(H1), pid₁(N2)) -> F
eqt₂(tuplenil₁(H1), int₁(N2)) -> F
eqt₂(tuplenil₁(H1), cons₂(H2, T2)) -> F
eqt₂(tuplenil₁(H1), tuple₂(H2, T2)) -> F
eqt₂(tuplenil₁(H1), tuplenil₁(H2)) -> eqt₂(H1, H2)
element₂(int₁(s₁(0)), tuplenil₁(T1)) -> T1
element₂(int₁(s₁(0)), tuple₂(T1, T2)) -> T1
element₂(int₁(s₁(s₁(N1))), tuple₂(T1, T2)) -> element₂(int₁(s₁(N1)), T2)
record_new₁(lock) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(undefined, tuple₂(nil, tuplenil₁(nil)))))
record_extract₃(tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2))))), lock, resource) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2)))))
record_update₄(tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2))))), lock, pending, NewF) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(NewF)))))
record_updates₃(Record, Name, nil) -> Record
record_updates₃(Record, Name, cons₂(tuple₂(Field, tuplenil₁(NewF)), Fields)) -> record_updates₃(record_update₄(Record, Name, Field, NewF), Name, Fields)
locker2_map_promote_pending₂(nil, Pending) -> nil
locker2_map_promote_pending₂(cons₂(Lock, Locks), Pending) -> cons₂(locker2_promote_pending₂(Lock, Pending), locker2_map_promote_pending₂(Locks, Pending))
locker2_map_claim_lock₃(nil, Resources, Client) -> nil
locker2_map_claim_lock₃(cons₂(Lock, Locks), Resources, Client) -> cons₂(locker2_claim_lock₃(Lock, Resources, Client), locker2_map_claim_lock₃(Locks, Resources, Client))
locker2_map_add_pending₃(nil, Resources, Client) -> nil
locker2_promote_pending₂(Lock, Client) -> case0₃(Client, Lock, record_extract₃(Lock, lock, pending))
case0₃(Client, Lock, cons₂(Client, Pendings)) -> record_updates₃(Lock, lock, cons₂(tuple₂(excl, tuplenil₁(Client)), cons₂(tuple₂(pending, tuplenil₁(Pendings)), nil)))
case0₃(Client, Lock, MCRLFree0) -> Lock
locker2_remove_pending₂(Lock, Client) -> record_updates₃(Lock, lock, cons₂(tuple₂(pending, tuplenil₁(subtract₂(record_extract₃(Lock, lock, pending), cons₂(Client, nil)))), nil))
locker2_add_pending₃(Lock, Resources, Client) -> case1₄(Client, Resources, Lock, member₂(record_extract₃(Lock, lock, resource), Resources))
case1₄(Client, Resources, Lock, true) -> record_updates₃(Lock, lock, cons₂(tuple₂(pending, tuplenil₁(append₂(record_extract₃(Lock, lock, pending), cons₂(Client, nil)))), nil))
case1₄(Client, Resources, Lock, false) -> Lock
locker2_release_lock₂(Lock, Client) -> case2₃(Client, Lock, gen_modtageq₂(Client, record_extract₃(Lock, lock, excl)))
case2₃(Client, Lock, true) -> record_updates₃(Lock, lock, cons₂(tuple₂(excllock, excl), nil))
case4₃(Client, Lock, MCRLFree1) -> false
locker2_obtainables₂(nil, Client) -> true
locker2_obtainables₂(cons₂(Lock, Locks), Client) -> case5₄(Client, Locks, Lock, member₂(Client, record_extract₃(Lock, lock, pending)))
case5₄(Client, Locks, Lock, true) -> andt₂(locker2_obtainable₂(Lock, Client), locker2_obtainables₂(Locks, Client))
case5₄(Client, Locks, Lock, false) -> locker2_obtainables₂(Locks, Client)
locker2_check_available₂(Resource, nil) -> false
locker2_check_available₂(Resource, cons₂(Lock, Locks)) -> case6₄(Locks, Lock, Resource, equal₂(Resource, record_extract₃(Lock, lock, resource)))
case6₄(Locks, Lock, Resource, true) -> andt₂(equal₂(record_extract₃(Lock, lock, excl), nil), equal₂(record_extract₃(Lock, lock, pending), nil))
case6₄(Locks, Lock, Resource, false) -> locker2_check_available₂(Resource, Locks)
locker2_check_availables₂(nil, Locks) -> true
locker2_check_availables₂(cons₂(Resource, Resources), Locks) -> andt₂(locker2_check_available₂(Resource, Locks), locker2_check_availables₂(Resources, Locks))
locker2_adduniq₂(nil, List) -> List
append₂(cons₂(Head, Tail), List) -> cons₂(Head, append₂(Tail, List))
subtract₂(List, nil) -> List
subtract₂(List, cons₂(Head, Tail)) -> subtract₂(delete₂(Head, List), Tail)
delete₂(E, nil) -> nil
delete₂(E, cons₂(Head, Tail)) -> case8₄(Tail, Head, E, equal₂(E, Head))
case8₄(Tail, Head, E, true) -> Tail
case8₄(Tail, Head, E, false) -> cons₂(Head, delete₂(E, Tail))
gen_tag₁(Pid) -> tuple₂(Pid, tuplenil₁(tag))
gen_modtageq₂(Client1, Client2) -> equal₂(Client1, Client2)
member₂(E, nil) -> false
member₂(E, cons₂(Head, Tail)) -> case9₄(Tail, Head, E, equal₂(E, Head))
case9₄(Tail, Head, E, true) -> true
case9₄(Tail, Head, E, false) -> member₂(E, Tail)
eqs₂(empty, empty) -> T
eqs₂(empty, stack₂(E2, S2)) -> F
eqs₂(stack₂(E1, S1), empty) -> F
eqs₂(stack₂(E1, S1), stack₂(E2, S2)) -> and₂(eqt₂(E1, E2), eqs₂(S1, S2))
pushs₂(E1, S1) -> stack₂(E1, S1)
pops₁(stack₂(E1, S1)) -> S1
tops₁(stack₂(E1, S1)) -> E1
istops₂(E1, empty) -> F
istops₂(E1, stack₂(E2, S1)) -> eqt₂(E1, E2)
eqc₂(nocalls, nocalls) -> T
eqc₂(nocalls, calls₃(E2, S2, CS2)) -> F
eqc₂(calls₃(E1, S1, CS1), nocalls) -> F
eqc₂(calls₃(E1, S1, CS1), calls₃(E2, S2, CS2)) -> and₂(eqt₂(E1, E2), and₂(eqs₂(S1, S2), eqc₂(CS1, CS2)))
push₃(E1, E2, nocalls) -> calls₃(E1, stack₂(E2, empty), nocalls)
push₃(E1, E2, calls₃(E3, S1, CS1)) -> push1₆(E1, E2, E3, S1, CS1, eqt₂(E1, E3))
push1₆(E1, E2, E3, S1, CS1, T) -> calls₃(E3, pushs₂(E2, S1), CS1)

Q is empty.

↳ QTRS

  ↳ DependencyPairsProof

Q restricted rewrite system:
The TRS R consists of the following rules:

or₂(T, T) -> T
or₂(F, T) -> T
or₂(T, F) -> T
or₂(F, F) -> F
and₂(T, B) -> B
and₂(B, T) -> B
and₂(F, B) -> F
and₂(B, F) -> F
imp₂(T, B) -> B
imp₂(F, B) -> T
not₁(T) -> F
not₁(F) -> T
if₃(T, B1, B2) -> B1
if₃(F, B1, B2) -> B2
eq₂(T, T) -> T
eq₂(F, F) -> T
eq₂(T, F) -> F
eq₂(F, T) -> F
eqt₂(nil, undefined) -> F
eqt₂(nil, pid₁(N2)) -> F
eqt₂(nil, int₁(N2)) -> F
eqt₂(nil, cons₂(H2, T2)) -> F
eqt₂(nil, tuple₂(H2, T2)) -> F
eqt₂(nil, tuplenil₁(H2)) -> F
eqt₂(a, nil) -> F
eqt₂(a, a) -> T
eqt₂(a, excl) -> F
eqt₂(a, false) -> F
eqt₂(a, lock) -> F
eqt₂(a, locker) -> F
eqt₂(a, mcrlrecord) -> F
eqt₂(a, ok) -> F
eqt₂(a, pending) -> F
eqt₂(a, release) -> F
eqt₂(a, request) -> F
eqt₂(a, resource) -> F
eqt₂(a, tag) -> F
eqt₂(a, true) -> F
eqt₂(a, undefined) -> F
eqt₂(a, pid₁(N2)) -> F
eqt₂(a, int₁(N2)) -> F
eqt₂(a, cons₂(H2, T2)) -> F
eqt₂(a, tuple₂(H2, T2)) -> F
eqt₂(a, tuplenil₁(H2)) -> F
eqt₂(excl, nil) -> F
eqt₂(excl, a) -> F
eqt₂(excl, excl) -> T
eqt₂(excl, false) -> F
eqt₂(excl, lock) -> F
eqt₂(excl, locker) -> F
eqt₂(excl, mcrlrecord) -> F
eqt₂(excl, ok) -> F
eqt₂(excl, pending) -> F
eqt₂(excl, release) -> F
eqt₂(excl, request) -> F
eqt₂(excl, resource) -> F
eqt₂(excl, tag) -> F
eqt₂(excl, true) -> F
eqt₂(excl, undefined) -> F
eqt₂(excl, pid₁(N2)) -> F
eqt₂(excl, eqt₂(false, int₁(N2))) -> F
eqt₂(false, cons₂(H2, T2)) -> F
eqt₂(false, tuple₂(H2, T2)) -> F
eqt₂(false, tuplenil₁(H2)) -> F
eqt₂(lock, nil) -> F
eqt₂(lock, a) -> F
eqt₂(lock, excl) -> F
eqt₂(lock, false) -> F
eqt₂(lock, lock) -> T
eqt₂(lock, locker) -> F
eqt₂(lock, mcrlrecord) -> F
eqt₂(lock, ok) -> F
eqt₂(lock, pending) -> F
eqt₂(lock, release) -> F
eqt₂(lock, request) -> F
eqt₂(lock, resource) -> F
eqt₂(lock, tag) -> F
eqt₂(lock, true) -> F
eqt₂(lock, undefined) -> F
eqt₂(lock, pid₁(N2)) -> F
eqt₂(lock, int₁(N2)) -> F
eqt₂(lock, cons₂(H2, T2)) -> F
eqt₂(lock, tuple₂(H2, T2)) -> F
eqt₂(lock, tuplenil₁(H2)) -> F
eqt₂(locker, nil) -> F
eqt₂(locker, a) -> F
eqt₂(locker, excl) -> F
eqt₂(locker, false) -> F
eqt₂(locker, lock) -> F
eqt₂(locker, locker) -> T
eqt₂(locker, mcrlrecord) -> F
eqt₂(locker, ok) -> F
eqt₂(locker, pending) -> F
eqt₂(locker, release) -> F
eqt₂(locker, request) -> F
eqt₂(locker, resource) -> F
eqt₂(locker, tag) -> F
eqt₂(locker, true) -> F
eqt₂(locker, undefined) -> F
eqt₂(locker, pid₁(N2)) -> F
eqt₂(locker, int₁(N2)) -> F
eqt₂(locker, cons₂(H2, T2)) -> F
eqt₂(locker, tuple₂(H2, T2)) -> F
eqt₂(locker, tuplenil₁(H2)) -> F
eqt₂(mcrlrecord, nil) -> F
eqt₂(mcrlrecord, a) -> F
eqt₂(mcrlrecord, excl) -> F
eqt₂(mcrlrecord, false) -> F
eqt₂(mcrlrecord, lock) -> F
eqt₂(mcrlrecord, locker) -> F
eqt₂(mcrlrecord, mcrlrecord) -> T
eqt₂(mcrlrecord, ok) -> F
eqt₂(mcrlrecord, pending) -> F
eqt₂(mcrlrecord, release) -> F
eqt₂(mcrlrecord, request) -> F
eqt₂(mcrlrecord, resource) -> F
eqt₂(ok, resource) -> F
eqt₂(ok, tag) -> F
eqt₂(ok, true) -> F
eqt₂(ok, undefined) -> F
eqt₂(ok, pid₁(N2)) -> F
eqt₂(ok, int₁(N2)) -> F
eqt₂(ok, cons₂(H2, T2)) -> F
eqt₂(ok, tuple₂(H2, T2)) -> F
eqt₂(ok, tuplenil₁(H2)) -> F
eqt₂(pending, nil) -> F
eqt₂(pending, a) -> F
eqt₂(pending, excl) -> F
eqt₂(pending, false) -> F
eqt₂(pending, lock) -> F
eqt₂(pending, locker) -> F
eqt₂(pending, mcrlrecord) -> F
eqt₂(pending, ok) -> F
eqt₂(pending, pending) -> T
eqt₂(pending, release) -> F
eqt₂(pending, request) -> F
eqt₂(pending, resource) -> F
eqt₂(pending, tag) -> F
eqt₂(pending, true) -> F
eqt₂(pending, undefined) -> F
eqt₂(pending, pid₁(N2)) -> F
eqt₂(pending, int₁(N2)) -> F
eqt₂(pending, cons₂(H2, T2)) -> F
eqt₂(pending, tuple₂(H2, T2)) -> F
eqt₂(pending, tuplenil₁(H2)) -> F
eqt₂(release, nil) -> F
eqt₂(release, a) -> F
eqt₂(release, excl) -> F
eqt₂(release, false) -> F
eqt₂(release, lock) -> F
eqt₂(release, locker) -> F
eqt₂(release, mcrlrecord) -> F
eqt₂(release, ok) -> F
eqt₂(request, mcrlrecord) -> F
eqt₂(request, ok) -> F
eqt₂(request, pending) -> F
eqt₂(request, release) -> F
eqt₂(request, request) -> T
eqt₂(request, resource) -> F
eqt₂(request, tag) -> F
eqt₂(request, true) -> F
eqt₂(request, undefined) -> F
eqt₂(request, pid₁(N2)) -> F
eqt₂(request, int₁(N2)) -> F
eqt₂(request, cons₂(H2, T2)) -> F
eqt₂(request, tuple₂(H2, T2)) -> F
eqt₂(request, tuplenil₁(H2)) -> F
eqt₂(resource, nil) -> F
eqt₂(resource, a) -> F
eqt₂(resource, excl) -> F
eqt₂(resource, false) -> F
eqt₂(resource, lock) -> F
eqt₂(resource, locker) -> F
eqt₂(resource, mcrlrecord) -> F
eqt₂(resource, ok) -> F
eqt₂(resource, pending) -> F
eqt₂(resource, release) -> F
eqt₂(resource, request) -> F
eqt₂(resource, resource) -> T
eqt₂(resource, tag) -> F
eqt₂(resource, true) -> F
eqt₂(resource, undefined) -> F
eqt₂(resource, pid₁(N2)) -> F
eqt₂(resource, int₁(N2)) -> F
eqt₂(resource, cons₂(H2, T2)) -> F
eqt₂(resource, tuple₂(H2, T2)) -> F
eqt₂(resource, tuplenil₁(H2)) -> F
eqt₂(tag, nil) -> F
eqt₂(tag, a) -> F
eqt₂(tag, excl) -> F
eqt₂(tag, false) -> F
eqt₂(tag, lock) -> F
eqt₂(tag, locker) -> F
eqt₂(tag, mcrlrecord) -> F
eqt₂(tag, ok) -> F
eqt₂(tag, pending) -> F
eqt₂(tag, release) -> F
eqt₂(tag, request) -> F
eqt₂(tag, resource) -> F
eqt₂(tag, tag) -> T
eqt₂(tag, true) -> F
eqt₂(tag, undefined) -> F
eqt₂(tag, pid₁(N2)) -> F
eqt₂(tag, int₁(N2)) -> F
eqt₂(tag, cons₂(H2, T2)) -> F
eqt₂(tag, tuple₂(H2, T2)) -> F
eqt₂(tag, tuplenil₁(H2)) -> F
eqt₂(true, nil) -> F
eqt₂(true, a) -> F
eqt₂(true, excl) -> F
eqt₂(true, false) -> F
eqt₂(true, lock) -> F
eqt₂(true, locker) -> F
eqt₂(true, mcrlrecord) -> F
eqt₂(true, ok) -> F
eqt₂(true, pending) -> F
eqt₂(true, release) -> F
eqt₂(true, request) -> F
eqt₂(true, resource) -> F
eqt₂(true, tag) -> F
eqt₂(true, true) -> T
eqt₂(true, undefined) -> F
eqt₂(true, pid₁(N2)) -> F
eqt₂(true, int₁(N2)) -> F
eqt₂(true, cons₂(H2, T2)) -> F
eqt₂(true, tuple₂(H2, T2)) -> F
eqt₂(true, tuplenil₁(H2)) -> F
eqt₂(undefined, nil) -> F
eqt₂(undefined, a) -> F
eqt₂(undefined, tuplenil₁(H2)) -> F
eqt₂(pid₁(N1), nil) -> F
eqt₂(pid₁(N1), a) -> F
eqt₂(pid₁(N1), excl) -> F
eqt₂(pid₁(N1), false) -> F
eqt₂(pid₁(N1), lock) -> F
eqt₂(pid₁(N1), locker) -> F
eqt₂(pid₁(N1), mcrlrecord) -> F
eqt₂(pid₁(N1), ok) -> F
eqt₂(pid₁(N1), pending) -> F
eqt₂(pid₁(N1), release) -> F
eqt₂(pid₁(N1), request) -> F
eqt₂(pid₁(N1), resource) -> F
eqt₂(pid₁(N1), tag) -> F
eqt₂(pid₁(N1), true) -> F
eqt₂(pid₁(N1), undefined) -> F
eqt₂(pid₁(N1), pid₁(N2)) -> eqt₂(N1, N2)
eqt₂(pid₁(N1), int₁(N2)) -> F
eqt₂(pid₁(N1), cons₂(H2, T2)) -> F
eqt₂(pid₁(N1), tuple₂(H2, T2)) -> F
eqt₂(pid₁(N1), tuplenil₁(H2)) -> F
eqt₂(int₁(N1), nil) -> F
eqt₂(int₁(N1), a) -> F
eqt₂(int₁(N1), excl) -> F
eqt₂(int₁(N1), false) -> F
eqt₂(int₁(N1), lock) -> F
eqt₂(int₁(N1), locker) -> F
eqt₂(int₁(N1), mcrlrecord) -> F
eqt₂(int₁(N1), ok) -> F
eqt₂(int₁(N1), pending) -> F
eqt₂(int₁(N1), release) -> F
eqt₂(int₁(N1), request) -> F
eqt₂(int₁(N1), resource) -> F
eqt₂(int₁(N1), tag) -> F
eqt₂(int₁(N1), true) -> F
eqt₂(int₁(N1), undefined) -> F
eqt₂(cons₂(H1, T1), resource) -> F
eqt₂(cons₂(H1, T1), tag) -> F
eqt₂(cons₂(H1, T1), true) -> F
eqt₂(cons₂(H1, T1), undefined) -> F
eqt₂(cons₂(H1, T1), pid₁(N2)) -> F
eqt₂(cons₂(H1, T1), int₁(N2)) -> F
eqt₂(cons₂(H1, T1), cons₂(H2, T2)) -> and₂(eqt₂(H1, H2), eqt₂(T1, T2))
eqt₂(cons₂(H1, T1), tuple₂(H2, T2)) -> F
eqt₂(cons₂(H1, T1), tuplenil₁(H2)) -> F
eqt₂(tuple₂(H1, T1), nil) -> F
eqt₂(tuple₂(H1, T1), a) -> F
eqt₂(tuple₂(H1, T1), excl) -> F
eqt₂(tuple₂(H1, T1), false) -> F
eqt₂(tuple₂(H1, T1), lock) -> F
eqt₂(tuple₂(H1, T1), locker) -> F
eqt₂(tuple₂(H1, T1), mcrlrecord) -> F
eqt₂(tuple₂(H1, T1), ok) -> F
eqt₂(tuple₂(H1, T1), pending) -> F
eqt₂(tuple₂(H1, T1), release) -> F
eqt₂(tuple₂(H1, T1), request) -> F
eqt₂(tuple₂(H1, T1), resource) -> F
eqt₂(tuple₂(H1, T1), tag) -> F
eqt₂(tuple₂(H1, T1), true) -> F
eqt₂(tuple₂(H1, T1), undefined) -> F
eqt₂(tuple₂(H1, T1), pid₁(N2)) -> F
eqt₂(tuple₂(H1, T1), int₁(N2)) -> F
eqt₂(tuple₂(H1, T1), cons₂(H2, T2)) -> F
eqt₂(tuple₂(H1, T1), tuple₂(H2, T2)) -> and₂(eqt₂(H1, H2), eqt₂(T1, T2))
eqt₂(tuple₂(H1, T1), tuplenil₁(H2)) -> F
eqt₂(tuplenil₁(H1), nil) -> F
eqt₂(tuplenil₁(H1), a) -> F
eqt₂(tuplenil₁(H1), excl) -> F
eqt₂(tuplenil₁(H1), false) -> F
eqt₂(tuplenil₁(H1), lock) -> F
eqt₂(tuplenil₁(H1), locker) -> F
eqt₂(tuplenil₁(H1), mcrlrecord) -> F
eqt₂(tuplenil₁(H1), ok) -> F
eqt₂(tuplenil₁(H1), pending) -> F
eqt₂(tuplenil₁(H1), release) -> F
eqt₂(tuplenil₁(H1), request) -> F
eqt₂(tuplenil₁(H1), resource) -> F
eqt₂(tuplenil₁(H1), tag) -> F
eqt₂(tuplenil₁(H1), true) -> F
eqt₂(tuplenil₁(H1), undefined) -> F
eqt₂(tuplenil₁(H1), pid₁(N2)) -> F
eqt₂(tuplenil₁(H1), int₁(N2)) -> F
eqt₂(tuplenil₁(H1), cons₂(H2, T2)) -> F
eqt₂(tuplenil₁(H1), tuple₂(H2, T2)) -> F
eqt₂(tuplenil₁(H1), tuplenil₁(H2)) -> eqt₂(H1, H2)
element₂(int₁(s₁(0)), tuplenil₁(T1)) -> T1
element₂(int₁(s₁(0)), tuple₂(T1, T2)) -> T1
element₂(int₁(s₁(s₁(N1))), tuple₂(T1, T2)) -> element₂(int₁(s₁(N1)), T2)
record_new₁(lock) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(undefined, tuple₂(nil, tuplenil₁(nil)))))
record_extract₃(tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2))))), lock, resource) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2)))))
record_update₄(tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2))))), lock, pending, NewF) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(NewF)))))
record_updates₃(Record, Name, nil) -> Record
record_updates₃(Record, Name, cons₂(tuple₂(Field, tuplenil₁(NewF)), Fields)) -> record_updates₃(record_update₄(Record, Name, Field, NewF), Name, Fields)
locker2_map_promote_pending₂(nil, Pending) -> nil
locker2_map_promote_pending₂(cons₂(Lock, Locks), Pending) -> cons₂(locker2_promote_pending₂(Lock, Pending), locker2_map_promote_pending₂(Locks, Pending))
locker2_map_claim_lock₃(nil, Resources, Client) -> nil
locker2_map_claim_lock₃(cons₂(Lock, Locks), Resources, Client) -> cons₂(locker2_claim_lock₃(Lock, Resources, Client), locker2_map_claim_lock₃(Locks, Resources, Client))
locker2_map_add_pending₃(nil, Resources, Client) -> nil
locker2_promote_pending₂(Lock, Client) -> case0₃(Client, Lock, record_extract₃(Lock, lock, pending))
case0₃(Client, Lock, cons₂(Client, Pendings)) -> record_updates₃(Lock, lock, cons₂(tuple₂(excl, tuplenil₁(Client)), cons₂(tuple₂(pending, tuplenil₁(Pendings)), nil)))
case0₃(Client, Lock, MCRLFree0) -> Lock
locker2_remove_pending₂(Lock, Client) -> record_updates₃(Lock, lock, cons₂(tuple₂(pending, tuplenil₁(subtract₂(record_extract₃(Lock, lock, pending), cons₂(Client, nil)))), nil))
locker2_add_pending₃(Lock, Resources, Client) -> case1₄(Client, Resources, Lock, member₂(record_extract₃(Lock, lock, resource), Resources))
case1₄(Client, Resources, Lock, true) -> record_updates₃(Lock, lock, cons₂(tuple₂(pending, tuplenil₁(append₂(record_extract₃(Lock, lock, pending), cons₂(Client, nil)))), nil))
case1₄(Client, Resources, Lock, false) -> Lock
locker2_release_lock₂(Lock, Client) -> case2₃(Client, Lock, gen_modtageq₂(Client, record_extract₃(Lock, lock, excl)))
case2₃(Client, Lock, true) -> record_updates₃(Lock, lock, cons₂(tuple₂(excllock, excl), nil))
case4₃(Client, Lock, MCRLFree1) -> false
locker2_obtainables₂(nil, Client) -> true
locker2_obtainables₂(cons₂(Lock, Locks), Client) -> case5₄(Client, Locks, Lock, member₂(Client, record_extract₃(Lock, lock, pending)))
case5₄(Client, Locks, Lock, true) -> andt₂(locker2_obtainable₂(Lock, Client), locker2_obtainables₂(Locks, Client))
case5₄(Client, Locks, Lock, false) -> locker2_obtainables₂(Locks, Client)
locker2_check_available₂(Resource, nil) -> false
locker2_check_available₂(Resource, cons₂(Lock, Locks)) -> case6₄(Locks, Lock, Resource, equal₂(Resource, record_extract₃(Lock, lock, resource)))
case6₄(Locks, Lock, Resource, true) -> andt₂(equal₂(record_extract₃(Lock, lock, excl), nil), equal₂(record_extract₃(Lock, lock, pending), nil))
case6₄(Locks, Lock, Resource, false) -> locker2_check_available₂(Resource, Locks)
locker2_check_availables₂(nil, Locks) -> true
locker2_check_availables₂(cons₂(Resource, Resources), Locks) -> andt₂(locker2_check_available₂(Resource, Locks), locker2_check_availables₂(Resources, Locks))
locker2_adduniq₂(nil, List) -> List
append₂(cons₂(Head, Tail), List) -> cons₂(Head, append₂(Tail, List))
subtract₂(List, nil) -> List
subtract₂(List, cons₂(Head, Tail)) -> subtract₂(delete₂(Head, List), Tail)
delete₂(E, nil) -> nil
delete₂(E, cons₂(Head, Tail)) -> case8₄(Tail, Head, E, equal₂(E, Head))
case8₄(Tail, Head, E, true) -> Tail
case8₄(Tail, Head, E, false) -> cons₂(Head, delete₂(E, Tail))
gen_tag₁(Pid) -> tuple₂(Pid, tuplenil₁(tag))
gen_modtageq₂(Client1, Client2) -> equal₂(Client1, Client2)
member₂(E, nil) -> false
member₂(E, cons₂(Head, Tail)) -> case9₄(Tail, Head, E, equal₂(E, Head))
case9₄(Tail, Head, E, true) -> true
case9₄(Tail, Head, E, false) -> member₂(E, Tail)
eqs₂(empty, empty) -> T
eqs₂(empty, stack₂(E2, S2)) -> F
eqs₂(stack₂(E1, S1), empty) -> F
eqs₂(stack₂(E1, S1), stack₂(E2, S2)) -> and₂(eqt₂(E1, E2), eqs₂(S1, S2))
pushs₂(E1, S1) -> stack₂(E1, S1)
pops₁(stack₂(E1, S1)) -> S1
tops₁(stack₂(E1, S1)) -> E1
istops₂(E1, empty) -> F
istops₂(E1, stack₂(E2, S1)) -> eqt₂(E1, E2)
eqc₂(nocalls, nocalls) -> T
eqc₂(nocalls, calls₃(E2, S2, CS2)) -> F
eqc₂(calls₃(E1, S1, CS1), nocalls) -> F
eqc₂(calls₃(E1, S1, CS1), calls₃(E2, S2, CS2)) -> and₂(eqt₂(E1, E2), and₂(eqs₂(S1, S2), eqc₂(CS1, CS2)))
push₃(E1, E2, nocalls) -> calls₃(E1, stack₂(E2, empty), nocalls)
push₃(E1, E2, calls₃(E3, S1, CS1)) -> push1₆(E1, E2, E3, S1, CS1, eqt₂(E1, E3))
push1₆(E1, E2, E3, S1, CS1, T) -> calls₃(E3, pushs₂(E2, S1), CS1)

Q is empty.

Using Dependency Pairs [1,13] we result in the following initial DP problem:
Q DP problem:
The TRS P consists of the following rules:

PUSH₃(E1, E2, calls₃(E3, S1, CS1)) -> EQT₂(E1, E3)
EQT₂(tuple₂(H1, T1), tuple₂(H2, T2)) -> EQT₂(H1, H2)
SUBTRACT₂(List, cons₂(Head, Tail)) -> DELETE₂(Head, List)
EQS₂(stack₂(E1, S1), stack₂(E2, S2)) -> AND₂(eqt₂(E1, E2), eqs₂(S1, S2))
LOCKER2_RELEASE_LOCK₂(Lock, Client) -> RECORD_EXTRACT₃(Lock, lock, excl)
LOCKER2_REMOVE_PENDING₂(Lock, Client) -> RECORD_UPDATES₃(Lock, lock, cons₂(tuple₂(pending, tuplenil₁(subtract₂(record_extract₃(Lock, lock, pending), cons₂(Client, nil)))), nil))
LOCKER2_MAP_PROMOTE_PENDING₂(cons₂(Lock, Locks), Pending) -> LOCKER2_PROMOTE_PENDING₂(Lock, Pending)
LOCKER2_CHECK_AVAILABLE₂(Resource, cons₂(Lock, Locks)) -> RECORD_EXTRACT₃(Lock, lock, resource)
EQC₂(calls₃(E1, S1, CS1), calls₃(E2, S2, CS2)) -> EQC₂(CS1, CS2)
LOCKER2_CHECK_AVAILABLES₂(cons₂(Resource, Resources), Locks) -> LOCKER2_CHECK_AVAILABLE₂(Resource, Locks)
CASE0₃(Client, Lock, cons₂(Client, Pendings)) -> RECORD_UPDATES₃(Lock, lock, cons₂(tuple₂(excl, tuplenil₁(Client)), cons₂(tuple₂(pending, tuplenil₁(Pendings)), nil)))
ELEMENT₂(int₁(s₁(s₁(N1))), tuple₂(T1, T2)) -> ELEMENT₂(int₁(s₁(N1)), T2)
MEMBER₂(E, cons₂(Head, Tail)) -> CASE9₄(Tail, Head, E, equal₂(E, Head))
EQT₂(cons₂(H1, T1), cons₂(H2, T2)) -> AND₂(eqt₂(H1, H2), eqt₂(T1, T2))
LOCKER2_MAP_CLAIM_LOCK₃(cons₂(Lock, Locks), Resources, Client) -> LOCKER2_MAP_CLAIM_LOCK₃(Locks, Resources, Client)
LOCKER2_OBTAINABLES₂(cons₂(Lock, Locks), Client) -> RECORD_EXTRACT₃(Lock, lock, pending)
CASE5₄(Client, Locks, Lock, true) -> LOCKER2_OBTAINABLES₂(Locks, Client)
PUSH1₆(E1, E2, E3, S1, CS1, T) -> PUSHS₂(E2, S1)
LOCKER2_MAP_PROMOTE_PENDING₂(cons₂(Lock, Locks), Pending) -> LOCKER2_MAP_PROMOTE_PENDING₂(Locks, Pending)
SUBTRACT₂(List, cons₂(Head, Tail)) -> SUBTRACT₂(delete₂(Head, List), Tail)
DELETE₂(E, cons₂(Head, Tail)) -> CASE8₄(Tail, Head, E, equal₂(E, Head))
CASE9₄(Tail, Head, E, false) -> MEMBER₂(E, Tail)
LOCKER2_ADD_PENDING₃(Lock, Resources, Client) -> CASE1₄(Client, Resources, Lock, member₂(record_extract₃(Lock, lock, resource), Resources))
LOCKER2_PROMOTE_PENDING₂(Lock, Client) -> CASE0₃(Client, Lock, record_extract₃(Lock, lock, pending))
RECORD_UPDATES₃(Record, Name, cons₂(tuple₂(Field, tuplenil₁(NewF)), Fields)) -> RECORD_UPDATES₃(record_update₄(Record, Name, Field, NewF), Name, Fields)
LOCKER2_PROMOTE_PENDING₂(Lock, Client) -> RECORD_EXTRACT₃(Lock, lock, pending)
LOCKER2_REMOVE_PENDING₂(Lock, Client) -> RECORD_EXTRACT₃(Lock, lock, pending)
CASE2₃(Client, Lock, true) -> RECORD_UPDATES₃(Lock, lock, cons₂(tuple₂(excllock, excl), nil))
EQC₂(calls₃(E1, S1, CS1), calls₃(E2, S2, CS2)) -> AND₂(eqt₂(E1, E2), and₂(eqs₂(S1, S2), eqc₂(CS1, CS2)))
RECORD_UPDATES₃(Record, Name, cons₂(tuple₂(Field, tuplenil₁(NewF)), Fields)) -> RECORD_UPDATE₄(Record, Name, Field, NewF)
LOCKER2_OBTAINABLES₂(cons₂(Lock, Locks), Client) -> MEMBER₂(Client, record_extract₃(Lock, lock, pending))
EQS₂(stack₂(E1, S1), stack₂(E2, S2)) -> EQS₂(S1, S2)
CASE6₄(Locks, Lock, Resource, false) -> LOCKER2_CHECK_AVAILABLE₂(Resource, Locks)
CASE1₄(Client, Resources, Lock, true) -> APPEND₂(record_extract₃(Lock, lock, pending), cons₂(Client, nil))
CASE1₄(Client, Resources, Lock, true) -> RECORD_UPDATES₃(Lock, lock, cons₂(tuple₂(pending, tuplenil₁(append₂(record_extract₃(Lock, lock, pending), cons₂(Client, nil)))), nil))
LOCKER2_ADD_PENDING₃(Lock, Resources, Client) -> RECORD_EXTRACT₃(Lock, lock, resource)
LOCKER2_RELEASE_LOCK₂(Lock, Client) -> CASE2₃(Client, Lock, gen_modtageq₂(Client, record_extract₃(Lock, lock, excl)))
LOCKER2_ADD_PENDING₃(Lock, Resources, Client) -> MEMBER₂(record_extract₃(Lock, lock, resource), Resources)
CASE1₄(Client, Resources, Lock, true) -> RECORD_EXTRACT₃(Lock, lock, pending)
CASE6₄(Locks, Lock, Resource, true) -> RECORD_EXTRACT₃(Lock, lock, excl)
LOCKER2_RELEASE_LOCK₂(Lock, Client) -> GEN_MODTAGEQ₂(Client, record_extract₃(Lock, lock, excl))
PUSH₃(E1, E2, calls₃(E3, S1, CS1)) -> PUSH1₆(E1, E2, E3, S1, CS1, eqt₂(E1, E3))
EQT₂(tuple₂(H1, T1), tuple₂(H2, T2)) -> EQT₂(T1, T2)
EQT₂(tuple₂(H1, T1), tuple₂(H2, T2)) -> AND₂(eqt₂(H1, H2), eqt₂(T1, T2))
LOCKER2_OBTAINABLES₂(cons₂(Lock, Locks), Client) -> CASE5₄(Client, Locks, Lock, member₂(Client, record_extract₃(Lock, lock, pending)))
EQT₂(tuplenil₁(H1), tuplenil₁(H2)) -> EQT₂(H1, H2)
EQS₂(stack₂(E1, S1), stack₂(E2, S2)) -> EQT₂(E1, E2)
APPEND₂(cons₂(Head, Tail), List) -> APPEND₂(Tail, List)
EQC₂(calls₃(E1, S1, CS1), calls₃(E2, S2, CS2)) -> EQT₂(E1, E2)
EQT₂(cons₂(H1, T1), cons₂(H2, T2)) -> EQT₂(T1, T2)
LOCKER2_CHECK_AVAILABLE₂(Resource, cons₂(Lock, Locks)) -> CASE6₄(Locks, Lock, Resource, equal₂(Resource, record_extract₃(Lock, lock, resource)))
CASE6₄(Locks, Lock, Resource, true) -> RECORD_EXTRACT₃(Lock, lock, pending)
ISTOPS₂(E1, stack₂(E2, S1)) -> EQT₂(E1, E2)
EQT₂(cons₂(H1, T1), cons₂(H2, T2)) -> EQT₂(H1, H2)
EQT₂(pid₁(N1), pid₁(N2)) -> EQT₂(N1, N2)
EQC₂(calls₃(E1, S1, CS1), calls₃(E2, S2, CS2)) -> AND₂(eqs₂(S1, S2), eqc₂(CS1, CS2))
LOCKER2_REMOVE_PENDING₂(Lock, Client) -> SUBTRACT₂(record_extract₃(Lock, lock, pending), cons₂(Client, nil))
LOCKER2_CHECK_AVAILABLES₂(cons₂(Resource, Resources), Locks) -> LOCKER2_CHECK_AVAILABLES₂(Resources, Locks)
EQC₂(calls₃(E1, S1, CS1), calls₃(E2, S2, CS2)) -> EQS₂(S1, S2)
CASE5₄(Client, Locks, Lock, false) -> LOCKER2_OBTAINABLES₂(Locks, Client)
CASE8₄(Tail, Head, E, false) -> DELETE₂(E, Tail)

The TRS R consists of the following rules:

or₂(T, T) -> T
or₂(F, T) -> T
or₂(T, F) -> T
or₂(F, F) -> F
and₂(T, B) -> B
and₂(B, T) -> B
and₂(F, B) -> F
and₂(B, F) -> F
imp₂(T, B) -> B
imp₂(F, B) -> T
not₁(T) -> F
not₁(F) -> T
if₃(T, B1, B2) -> B1
if₃(F, B1, B2) -> B2
eq₂(T, T) -> T
eq₂(F, F) -> T
eq₂(T, F) -> F
eq₂(F, T) -> F
eqt₂(nil, undefined) -> F
eqt₂(nil, pid₁(N2)) -> F
eqt₂(nil, int₁(N2)) -> F
eqt₂(nil, cons₂(H2, T2)) -> F
eqt₂(nil, tuple₂(H2, T2)) -> F
eqt₂(nil, tuplenil₁(H2)) -> F
eqt₂(a, nil) -> F
eqt₂(a, a) -> T
eqt₂(a, excl) -> F
eqt₂(a, false) -> F
eqt₂(a, lock) -> F
eqt₂(a, locker) -> F
eqt₂(a, mcrlrecord) -> F
eqt₂(a, ok) -> F
eqt₂(a, pending) -> F
eqt₂(a, release) -> F
eqt₂(a, request) -> F
eqt₂(a, resource) -> F
eqt₂(a, tag) -> F
eqt₂(a, true) -> F
eqt₂(a, undefined) -> F
eqt₂(a, pid₁(N2)) -> F
eqt₂(a, int₁(N2)) -> F
eqt₂(a, cons₂(H2, T2)) -> F
eqt₂(a, tuple₂(H2, T2)) -> F
eqt₂(a, tuplenil₁(H2)) -> F
eqt₂(excl, nil) -> F
eqt₂(excl, a) -> F
eqt₂(excl, excl) -> T
eqt₂(excl, false) -> F
eqt₂(excl, lock) -> F
eqt₂(excl, locker) -> F
eqt₂(excl, mcrlrecord) -> F
eqt₂(excl, ok) -> F
eqt₂(excl, pending) -> F
eqt₂(excl, release) -> F
eqt₂(excl, request) -> F
eqt₂(excl, resource) -> F
eqt₂(excl, tag) -> F
eqt₂(excl, true) -> F
eqt₂(excl, undefined) -> F
eqt₂(excl, pid₁(N2)) -> F
eqt₂(excl, eqt₂(false, int₁(N2))) -> F
eqt₂(false, cons₂(H2, T2)) -> F
eqt₂(false, tuple₂(H2, T2)) -> F
eqt₂(false, tuplenil₁(H2)) -> F
eqt₂(lock, nil) -> F
eqt₂(lock, a) -> F
eqt₂(lock, excl) -> F
eqt₂(lock, false) -> F
eqt₂(lock, lock) -> T
eqt₂(lock, locker) -> F
eqt₂(lock, mcrlrecord) -> F
eqt₂(lock, ok) -> F
eqt₂(lock, pending) -> F
eqt₂(lock, release) -> F
eqt₂(lock, request) -> F
eqt₂(lock, resource) -> F
eqt₂(lock, tag) -> F
eqt₂(lock, true) -> F
eqt₂(lock, undefined) -> F
eqt₂(lock, pid₁(N2)) -> F
eqt₂(lock, int₁(N2)) -> F
eqt₂(lock, cons₂(H2, T2)) -> F
eqt₂(lock, tuple₂(H2, T2)) -> F
eqt₂(lock, tuplenil₁(H2)) -> F
eqt₂(locker, nil) -> F
eqt₂(locker, a) -> F
eqt₂(locker, excl) -> F
eqt₂(locker, false) -> F
eqt₂(locker, lock) -> F
eqt₂(locker, locker) -> T
eqt₂(locker, mcrlrecord) -> F
eqt₂(locker, ok) -> F
eqt₂(locker, pending) -> F
eqt₂(locker, release) -> F
eqt₂(locker, request) -> F
eqt₂(locker, resource) -> F
eqt₂(locker, tag) -> F
eqt₂(locker, true) -> F
eqt₂(locker, undefined) -> F
eqt₂(locker, pid₁(N2)) -> F
eqt₂(locker, int₁(N2)) -> F
eqt₂(locker, cons₂(H2, T2)) -> F
eqt₂(locker, tuple₂(H2, T2)) -> F
eqt₂(locker, tuplenil₁(H2)) -> F
eqt₂(mcrlrecord, nil) -> F
eqt₂(mcrlrecord, a) -> F
eqt₂(mcrlrecord, excl) -> F
eqt₂(mcrlrecord, false) -> F
eqt₂(mcrlrecord, lock) -> F
eqt₂(mcrlrecord, locker) -> F
eqt₂(mcrlrecord, mcrlrecord) -> T
eqt₂(mcrlrecord, ok) -> F
eqt₂(mcrlrecord, pending) -> F
eqt₂(mcrlrecord, release) -> F
eqt₂(mcrlrecord, request) -> F
eqt₂(mcrlrecord, resource) -> F
eqt₂(ok, resource) -> F
eqt₂(ok, tag) -> F
eqt₂(ok, true) -> F
eqt₂(ok, undefined) -> F
eqt₂(ok, pid₁(N2)) -> F
eqt₂(ok, int₁(N2)) -> F
eqt₂(ok, cons₂(H2, T2)) -> F
eqt₂(ok, tuple₂(H2, T2)) -> F
eqt₂(ok, tuplenil₁(H2)) -> F
eqt₂(pending, nil) -> F
eqt₂(pending, a) -> F
eqt₂(pending, excl) -> F
eqt₂(pending, false) -> F
eqt₂(pending, lock) -> F
eqt₂(pending, locker) -> F
eqt₂(pending, mcrlrecord) -> F
eqt₂(pending, ok) -> F
eqt₂(pending, pending) -> T
eqt₂(pending, release) -> F
eqt₂(pending, request) -> F
eqt₂(pending, resource) -> F
eqt₂(pending, tag) -> F
eqt₂(pending, true) -> F
eqt₂(pending, undefined) -> F
eqt₂(pending, pid₁(N2)) -> F
eqt₂(pending, int₁(N2)) -> F
eqt₂(pending, cons₂(H2, T2)) -> F
eqt₂(pending, tuple₂(H2, T2)) -> F
eqt₂(pending, tuplenil₁(H2)) -> F
eqt₂(release, nil) -> F
eqt₂(release, a) -> F
eqt₂(release, excl) -> F
eqt₂(release, false) -> F
eqt₂(release, lock) -> F
eqt₂(release, locker) -> F
eqt₂(release, mcrlrecord) -> F
eqt₂(release, ok) -> F
eqt₂(request, mcrlrecord) -> F
eqt₂(request, ok) -> F
eqt₂(request, pending) -> F
eqt₂(request, release) -> F
eqt₂(request, request) -> T
eqt₂(request, resource) -> F
eqt₂(request, tag) -> F
eqt₂(request, true) -> F
eqt₂(request, undefined) -> F
eqt₂(request, pid₁(N2)) -> F
eqt₂(request, int₁(N2)) -> F
eqt₂(request, cons₂(H2, T2)) -> F
eqt₂(request, tuple₂(H2, T2)) -> F
eqt₂(request, tuplenil₁(H2)) -> F
eqt₂(resource, nil) -> F
eqt₂(resource, a) -> F
eqt₂(resource, excl) -> F
eqt₂(resource, false) -> F
eqt₂(resource, lock) -> F
eqt₂(resource, locker) -> F
eqt₂(resource, mcrlrecord) -> F
eqt₂(resource, ok) -> F
eqt₂(resource, pending) -> F
eqt₂(resource, release) -> F
eqt₂(resource, request) -> F
eqt₂(resource, resource) -> T
eqt₂(resource, tag) -> F
eqt₂(resource, true) -> F
eqt₂(resource, undefined) -> F
eqt₂(resource, pid₁(N2)) -> F
eqt₂(resource, int₁(N2)) -> F
eqt₂(resource, cons₂(H2, T2)) -> F
eqt₂(resource, tuple₂(H2, T2)) -> F
eqt₂(resource, tuplenil₁(H2)) -> F
eqt₂(tag, nil) -> F
eqt₂(tag, a) -> F
eqt₂(tag, excl) -> F
eqt₂(tag, false) -> F
eqt₂(tag, lock) -> F
eqt₂(tag, locker) -> F
eqt₂(tag, mcrlrecord) -> F
eqt₂(tag, ok) -> F
eqt₂(tag, pending) -> F
eqt₂(tag, release) -> F
eqt₂(tag, request) -> F
eqt₂(tag, resource) -> F
eqt₂(tag, tag) -> T
eqt₂(tag, true) -> F
eqt₂(tag, undefined) -> F
eqt₂(tag, pid₁(N2)) -> F
eqt₂(tag, int₁(N2)) -> F
eqt₂(tag, cons₂(H2, T2)) -> F
eqt₂(tag, tuple₂(H2, T2)) -> F
eqt₂(tag, tuplenil₁(H2)) -> F
eqt₂(true, nil) -> F
eqt₂(true, a) -> F
eqt₂(true, excl) -> F
eqt₂(true, false) -> F
eqt₂(true, lock) -> F
eqt₂(true, locker) -> F
eqt₂(true, mcrlrecord) -> F
eqt₂(true, ok) -> F
eqt₂(true, pending) -> F
eqt₂(true, release) -> F
eqt₂(true, request) -> F
eqt₂(true, resource) -> F
eqt₂(true, tag) -> F
eqt₂(true, true) -> T
eqt₂(true, undefined) -> F
eqt₂(true, pid₁(N2)) -> F
eqt₂(true, int₁(N2)) -> F
eqt₂(true, cons₂(H2, T2)) -> F
eqt₂(true, tuple₂(H2, T2)) -> F
eqt₂(true, tuplenil₁(H2)) -> F
eqt₂(undefined, nil) -> F
eqt₂(undefined, a) -> F
eqt₂(undefined, tuplenil₁(H2)) -> F
eqt₂(pid₁(N1), nil) -> F
eqt₂(pid₁(N1), a) -> F
eqt₂(pid₁(N1), excl) -> F
eqt₂(pid₁(N1), false) -> F
eqt₂(pid₁(N1), lock) -> F
eqt₂(pid₁(N1), locker) -> F
eqt₂(pid₁(N1), mcrlrecord) -> F
eqt₂(pid₁(N1), ok) -> F
eqt₂(pid₁(N1), pending) -> F
eqt₂(pid₁(N1), release) -> F
eqt₂(pid₁(N1), request) -> F
eqt₂(pid₁(N1), resource) -> F
eqt₂(pid₁(N1), tag) -> F
eqt₂(pid₁(N1), true) -> F
eqt₂(pid₁(N1), undefined) -> F
eqt₂(pid₁(N1), pid₁(N2)) -> eqt₂(N1, N2)
eqt₂(pid₁(N1), int₁(N2)) -> F
eqt₂(pid₁(N1), cons₂(H2, T2)) -> F
eqt₂(pid₁(N1), tuple₂(H2, T2)) -> F
eqt₂(pid₁(N1), tuplenil₁(H2)) -> F
eqt₂(int₁(N1), nil) -> F
eqt₂(int₁(N1), a) -> F
eqt₂(int₁(N1), excl) -> F
eqt₂(int₁(N1), false) -> F
eqt₂(int₁(N1), lock) -> F
eqt₂(int₁(N1), locker) -> F
eqt₂(int₁(N1), mcrlrecord) -> F
eqt₂(int₁(N1), ok) -> F
eqt₂(int₁(N1), pending) -> F
eqt₂(int₁(N1), release) -> F
eqt₂(int₁(N1), request) -> F
eqt₂(int₁(N1), resource) -> F
eqt₂(int₁(N1), tag) -> F
eqt₂(int₁(N1), true) -> F
eqt₂(int₁(N1), undefined) -> F
eqt₂(cons₂(H1, T1), resource) -> F
eqt₂(cons₂(H1, T1), tag) -> F
eqt₂(cons₂(H1, T1), true) -> F
eqt₂(cons₂(H1, T1), undefined) -> F
eqt₂(cons₂(H1, T1), pid₁(N2)) -> F
eqt₂(cons₂(H1, T1), int₁(N2)) -> F
eqt₂(cons₂(H1, T1), cons₂(H2, T2)) -> and₂(eqt₂(H1, H2), eqt₂(T1, T2))
eqt₂(cons₂(H1, T1), tuple₂(H2, T2)) -> F
eqt₂(cons₂(H1, T1), tuplenil₁(H2)) -> F
eqt₂(tuple₂(H1, T1), nil) -> F
eqt₂(tuple₂(H1, T1), a) -> F
eqt₂(tuple₂(H1, T1), excl) -> F
eqt₂(tuple₂(H1, T1), false) -> F
eqt₂(tuple₂(H1, T1), lock) -> F
eqt₂(tuple₂(H1, T1), locker) -> F
eqt₂(tuple₂(H1, T1), mcrlrecord) -> F
eqt₂(tuple₂(H1, T1), ok) -> F
eqt₂(tuple₂(H1, T1), pending) -> F
eqt₂(tuple₂(H1, T1), release) -> F
eqt₂(tuple₂(H1, T1), request) -> F
eqt₂(tuple₂(H1, T1), resource) -> F
eqt₂(tuple₂(H1, T1), tag) -> F
eqt₂(tuple₂(H1, T1), true) -> F
eqt₂(tuple₂(H1, T1), undefined) -> F
eqt₂(tuple₂(H1, T1), pid₁(N2)) -> F
eqt₂(tuple₂(H1, T1), int₁(N2)) -> F
eqt₂(tuple₂(H1, T1), cons₂(H2, T2)) -> F
eqt₂(tuple₂(H1, T1), tuple₂(H2, T2)) -> and₂(eqt₂(H1, H2), eqt₂(T1, T2))
eqt₂(tuple₂(H1, T1), tuplenil₁(H2)) -> F
eqt₂(tuplenil₁(H1), nil) -> F
eqt₂(tuplenil₁(H1), a) -> F
eqt₂(tuplenil₁(H1), excl) -> F
eqt₂(tuplenil₁(H1), false) -> F
eqt₂(tuplenil₁(H1), lock) -> F
eqt₂(tuplenil₁(H1), locker) -> F
eqt₂(tuplenil₁(H1), mcrlrecord) -> F
eqt₂(tuplenil₁(H1), ok) -> F
eqt₂(tuplenil₁(H1), pending) -> F
eqt₂(tuplenil₁(H1), release) -> F
eqt₂(tuplenil₁(H1), request) -> F
eqt₂(tuplenil₁(H1), resource) -> F
eqt₂(tuplenil₁(H1), tag) -> F
eqt₂(tuplenil₁(H1), true) -> F
eqt₂(tuplenil₁(H1), undefined) -> F
eqt₂(tuplenil₁(H1), pid₁(N2)) -> F
eqt₂(tuplenil₁(H1), int₁(N2)) -> F
eqt₂(tuplenil₁(H1), cons₂(H2, T2)) -> F
eqt₂(tuplenil₁(H1), tuple₂(H2, T2)) -> F
eqt₂(tuplenil₁(H1), tuplenil₁(H2)) -> eqt₂(H1, H2)
element₂(int₁(s₁(0)), tuplenil₁(T1)) -> T1
element₂(int₁(s₁(0)), tuple₂(T1, T2)) -> T1
element₂(int₁(s₁(s₁(N1))), tuple₂(T1, T2)) -> element₂(int₁(s₁(N1)), T2)
record_new₁(lock) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(undefined, tuple₂(nil, tuplenil₁(nil)))))
record_extract₃(tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2))))), lock, resource) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2)))))
record_update₄(tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2))))), lock, pending, NewF) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(NewF)))))
record_updates₃(Record, Name, nil) -> Record
record_updates₃(Record, Name, cons₂(tuple₂(Field, tuplenil₁(NewF)), Fields)) -> record_updates₃(record_update₄(Record, Name, Field, NewF), Name, Fields)
locker2_map_promote_pending₂(nil, Pending) -> nil
locker2_map_promote_pending₂(cons₂(Lock, Locks), Pending) -> cons₂(locker2_promote_pending₂(Lock, Pending), locker2_map_promote_pending₂(Locks, Pending))
locker2_map_claim_lock₃(nil, Resources, Client) -> nil
locker2_map_claim_lock₃(cons₂(Lock, Locks), Resources, Client) -> cons₂(locker2_claim_lock₃(Lock, Resources, Client), locker2_map_claim_lock₃(Locks, Resources, Client))
locker2_map_add_pending₃(nil, Resources, Client) -> nil
locker2_promote_pending₂(Lock, Client) -> case0₃(Client, Lock, record_extract₃(Lock, lock, pending))
case0₃(Client, Lock, cons₂(Client, Pendings)) -> record_updates₃(Lock, lock, cons₂(tuple₂(excl, tuplenil₁(Client)), cons₂(tuple₂(pending, tuplenil₁(Pendings)), nil)))
case0₃(Client, Lock, MCRLFree0) -> Lock
locker2_remove_pending₂(Lock, Client) -> record_updates₃(Lock, lock, cons₂(tuple₂(pending, tuplenil₁(subtract₂(record_extract₃(Lock, lock, pending), cons₂(Client, nil)))), nil))
locker2_add_pending₃(Lock, Resources, Client) -> case1₄(Client, Resources, Lock, member₂(record_extract₃(Lock, lock, resource), Resources))
case1₄(Client, Resources, Lock, true) -> record_updates₃(Lock, lock, cons₂(tuple₂(pending, tuplenil₁(append₂(record_extract₃(Lock, lock, pending), cons₂(Client, nil)))), nil))
case1₄(Client, Resources, Lock, false) -> Lock
locker2_release_lock₂(Lock, Client) -> case2₃(Client, Lock, gen_modtageq₂(Client, record_extract₃(Lock, lock, excl)))
case2₃(Client, Lock, true) -> record_updates₃(Lock, lock, cons₂(tuple₂(excllock, excl), nil))
case4₃(Client, Lock, MCRLFree1) -> false
locker2_obtainables₂(nil, Client) -> true
locker2_obtainables₂(cons₂(Lock, Locks), Client) -> case5₄(Client, Locks, Lock, member₂(Client, record_extract₃(Lock, lock, pending)))
case5₄(Client, Locks, Lock, true) -> andt₂(locker2_obtainable₂(Lock, Client), locker2_obtainables₂(Locks, Client))
case5₄(Client, Locks, Lock, false) -> locker2_obtainables₂(Locks, Client)
locker2_check_available₂(Resource, nil) -> false
locker2_check_available₂(Resource, cons₂(Lock, Locks)) -> case6₄(Locks, Lock, Resource, equal₂(Resource, record_extract₃(Lock, lock, resource)))
case6₄(Locks, Lock, Resource, true) -> andt₂(equal₂(record_extract₃(Lock, lock, excl), nil), equal₂(record_extract₃(Lock, lock, pending), nil))
case6₄(Locks, Lock, Resource, false) -> locker2_check_available₂(Resource, Locks)
locker2_check_availables₂(nil, Locks) -> true
locker2_check_availables₂(cons₂(Resource, Resources), Locks) -> andt₂(locker2_check_available₂(Resource, Locks), locker2_check_availables₂(Resources, Locks))
locker2_adduniq₂(nil, List) -> List
append₂(cons₂(Head, Tail), List) -> cons₂(Head, append₂(Tail, List))
subtract₂(List, nil) -> List
subtract₂(List, cons₂(Head, Tail)) -> subtract₂(delete₂(Head, List), Tail)
delete₂(E, nil) -> nil
delete₂(E, cons₂(Head, Tail)) -> case8₄(Tail, Head, E, equal₂(E, Head))
case8₄(Tail, Head, E, true) -> Tail
case8₄(Tail, Head, E, false) -> cons₂(Head, delete₂(E, Tail))
gen_tag₁(Pid) -> tuple₂(Pid, tuplenil₁(tag))
gen_modtageq₂(Client1, Client2) -> equal₂(Client1, Client2)
member₂(E, nil) -> false
member₂(E, cons₂(Head, Tail)) -> case9₄(Tail, Head, E, equal₂(E, Head))
case9₄(Tail, Head, E, true) -> true
case9₄(Tail, Head, E, false) -> member₂(E, Tail)
eqs₂(empty, empty) -> T
eqs₂(empty, stack₂(E2, S2)) -> F
eqs₂(stack₂(E1, S1), empty) -> F
eqs₂(stack₂(E1, S1), stack₂(E2, S2)) -> and₂(eqt₂(E1, E2), eqs₂(S1, S2))
pushs₂(E1, S1) -> stack₂(E1, S1)
pops₁(stack₂(E1, S1)) -> S1
tops₁(stack₂(E1, S1)) -> E1
istops₂(E1, empty) -> F
istops₂(E1, stack₂(E2, S1)) -> eqt₂(E1, E2)
eqc₂(nocalls, nocalls) -> T
eqc₂(nocalls, calls₃(E2, S2, CS2)) -> F
eqc₂(calls₃(E1, S1, CS1), nocalls) -> F
eqc₂(calls₃(E1, S1, CS1), calls₃(E2, S2, CS2)) -> and₂(eqt₂(E1, E2), and₂(eqs₂(S1, S2), eqc₂(CS1, CS2)))
push₃(E1, E2, nocalls) -> calls₃(E1, stack₂(E2, empty), nocalls)
push₃(E1, E2, calls₃(E3, S1, CS1)) -> push1₆(E1, E2, E3, S1, CS1, eqt₂(E1, E3))
push1₆(E1, E2, E3, S1, CS1, T) -> calls₃(E3, pushs₂(E2, S1), CS1)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

PUSH₃(E1, E2, calls₃(E3, S1, CS1)) -> EQT₂(E1, E3)
EQT₂(tuple₂(H1, T1), tuple₂(H2, T2)) -> EQT₂(H1, H2)
SUBTRACT₂(List, cons₂(Head, Tail)) -> DELETE₂(Head, List)
EQS₂(stack₂(E1, S1), stack₂(E2, S2)) -> AND₂(eqt₂(E1, E2), eqs₂(S1, S2))
LOCKER2_RELEASE_LOCK₂(Lock, Client) -> RECORD_EXTRACT₃(Lock, lock, excl)
LOCKER2_REMOVE_PENDING₂(Lock, Client) -> RECORD_UPDATES₃(Lock, lock, cons₂(tuple₂(pending, tuplenil₁(subtract₂(record_extract₃(Lock, lock, pending), cons₂(Client, nil)))), nil))
LOCKER2_MAP_PROMOTE_PENDING₂(cons₂(Lock, Locks), Pending) -> LOCKER2_PROMOTE_PENDING₂(Lock, Pending)
LOCKER2_CHECK_AVAILABLE₂(Resource, cons₂(Lock, Locks)) -> RECORD_EXTRACT₃(Lock, lock, resource)
EQC₂(calls₃(E1, S1, CS1), calls₃(E2, S2, CS2)) -> EQC₂(CS1, CS2)
LOCKER2_CHECK_AVAILABLES₂(cons₂(Resource, Resources), Locks) -> LOCKER2_CHECK_AVAILABLE₂(Resource, Locks)
CASE0₃(Client, Lock, cons₂(Client, Pendings)) -> RECORD_UPDATES₃(Lock, lock, cons₂(tuple₂(excl, tuplenil₁(Client)), cons₂(tuple₂(pending, tuplenil₁(Pendings)), nil)))
ELEMENT₂(int₁(s₁(s₁(N1))), tuple₂(T1, T2)) -> ELEMENT₂(int₁(s₁(N1)), T2)
MEMBER₂(E, cons₂(Head, Tail)) -> CASE9₄(Tail, Head, E, equal₂(E, Head))
EQT₂(cons₂(H1, T1), cons₂(H2, T2)) -> AND₂(eqt₂(H1, H2), eqt₂(T1, T2))
LOCKER2_MAP_CLAIM_LOCK₃(cons₂(Lock, Locks), Resources, Client) -> LOCKER2_MAP_CLAIM_LOCK₃(Locks, Resources, Client)
LOCKER2_OBTAINABLES₂(cons₂(Lock, Locks), Client) -> RECORD_EXTRACT₃(Lock, lock, pending)
CASE5₄(Client, Locks, Lock, true) -> LOCKER2_OBTAINABLES₂(Locks, Client)
PUSH1₆(E1, E2, E3, S1, CS1, T) -> PUSHS₂(E2, S1)
LOCKER2_MAP_PROMOTE_PENDING₂(cons₂(Lock, Locks), Pending) -> LOCKER2_MAP_PROMOTE_PENDING₂(Locks, Pending)
SUBTRACT₂(List, cons₂(Head, Tail)) -> SUBTRACT₂(delete₂(Head, List), Tail)
DELETE₂(E, cons₂(Head, Tail)) -> CASE8₄(Tail, Head, E, equal₂(E, Head))
CASE9₄(Tail, Head, E, false) -> MEMBER₂(E, Tail)
LOCKER2_ADD_PENDING₃(Lock, Resources, Client) -> CASE1₄(Client, Resources, Lock, member₂(record_extract₃(Lock, lock, resource), Resources))
LOCKER2_PROMOTE_PENDING₂(Lock, Client) -> CASE0₃(Client, Lock, record_extract₃(Lock, lock, pending))
RECORD_UPDATES₃(Record, Name, cons₂(tuple₂(Field, tuplenil₁(NewF)), Fields)) -> RECORD_UPDATES₃(record_update₄(Record, Name, Field, NewF), Name, Fields)
LOCKER2_PROMOTE_PENDING₂(Lock, Client) -> RECORD_EXTRACT₃(Lock, lock, pending)
LOCKER2_REMOVE_PENDING₂(Lock, Client) -> RECORD_EXTRACT₃(Lock, lock, pending)
CASE2₃(Client, Lock, true) -> RECORD_UPDATES₃(Lock, lock, cons₂(tuple₂(excllock, excl), nil))
EQC₂(calls₃(E1, S1, CS1), calls₃(E2, S2, CS2)) -> AND₂(eqt₂(E1, E2), and₂(eqs₂(S1, S2), eqc₂(CS1, CS2)))
RECORD_UPDATES₃(Record, Name, cons₂(tuple₂(Field, tuplenil₁(NewF)), Fields)) -> RECORD_UPDATE₄(Record, Name, Field, NewF)
LOCKER2_OBTAINABLES₂(cons₂(Lock, Locks), Client) -> MEMBER₂(Client, record_extract₃(Lock, lock, pending))
EQS₂(stack₂(E1, S1), stack₂(E2, S2)) -> EQS₂(S1, S2)
CASE6₄(Locks, Lock, Resource, false) -> LOCKER2_CHECK_AVAILABLE₂(Resource, Locks)
CASE1₄(Client, Resources, Lock, true) -> APPEND₂(record_extract₃(Lock, lock, pending), cons₂(Client, nil))
CASE1₄(Client, Resources, Lock, true) -> RECORD_UPDATES₃(Lock, lock, cons₂(tuple₂(pending, tuplenil₁(append₂(record_extract₃(Lock, lock, pending), cons₂(Client, nil)))), nil))
LOCKER2_ADD_PENDING₃(Lock, Resources, Client) -> RECORD_EXTRACT₃(Lock, lock, resource)
LOCKER2_RELEASE_LOCK₂(Lock, Client) -> CASE2₃(Client, Lock, gen_modtageq₂(Client, record_extract₃(Lock, lock, excl)))
LOCKER2_ADD_PENDING₃(Lock, Resources, Client) -> MEMBER₂(record_extract₃(Lock, lock, resource), Resources)
CASE1₄(Client, Resources, Lock, true) -> RECORD_EXTRACT₃(Lock, lock, pending)
CASE6₄(Locks, Lock, Resource, true) -> RECORD_EXTRACT₃(Lock, lock, excl)
LOCKER2_RELEASE_LOCK₂(Lock, Client) -> GEN_MODTAGEQ₂(Client, record_extract₃(Lock, lock, excl))
PUSH₃(E1, E2, calls₃(E3, S1, CS1)) -> PUSH1₆(E1, E2, E3, S1, CS1, eqt₂(E1, E3))
EQT₂(tuple₂(H1, T1), tuple₂(H2, T2)) -> EQT₂(T1, T2)
EQT₂(tuple₂(H1, T1), tuple₂(H2, T2)) -> AND₂(eqt₂(H1, H2), eqt₂(T1, T2))
LOCKER2_OBTAINABLES₂(cons₂(Lock, Locks), Client) -> CASE5₄(Client, Locks, Lock, member₂(Client, record_extract₃(Lock, lock, pending)))
EQT₂(tuplenil₁(H1), tuplenil₁(H2)) -> EQT₂(H1, H2)
EQS₂(stack₂(E1, S1), stack₂(E2, S2)) -> EQT₂(E1, E2)
APPEND₂(cons₂(Head, Tail), List) -> APPEND₂(Tail, List)
EQC₂(calls₃(E1, S1, CS1), calls₃(E2, S2, CS2)) -> EQT₂(E1, E2)
EQT₂(cons₂(H1, T1), cons₂(H2, T2)) -> EQT₂(T1, T2)
LOCKER2_CHECK_AVAILABLE₂(Resource, cons₂(Lock, Locks)) -> CASE6₄(Locks, Lock, Resource, equal₂(Resource, record_extract₃(Lock, lock, resource)))
CASE6₄(Locks, Lock, Resource, true) -> RECORD_EXTRACT₃(Lock, lock, pending)
ISTOPS₂(E1, stack₂(E2, S1)) -> EQT₂(E1, E2)
EQT₂(cons₂(H1, T1), cons₂(H2, T2)) -> EQT₂(H1, H2)
EQT₂(pid₁(N1), pid₁(N2)) -> EQT₂(N1, N2)
EQC₂(calls₃(E1, S1, CS1), calls₃(E2, S2, CS2)) -> AND₂(eqs₂(S1, S2), eqc₂(CS1, CS2))
LOCKER2_REMOVE_PENDING₂(Lock, Client) -> SUBTRACT₂(record_extract₃(Lock, lock, pending), cons₂(Client, nil))
LOCKER2_CHECK_AVAILABLES₂(cons₂(Resource, Resources), Locks) -> LOCKER2_CHECK_AVAILABLES₂(Resources, Locks)
EQC₂(calls₃(E1, S1, CS1), calls₃(E2, S2, CS2)) -> EQS₂(S1, S2)
CASE5₄(Client, Locks, Lock, false) -> LOCKER2_OBTAINABLES₂(Locks, Client)
CASE8₄(Tail, Head, E, false) -> DELETE₂(E, Tail)

The TRS R consists of the following rules:

or₂(T, T) -> T
or₂(F, T) -> T
or₂(T, F) -> T
or₂(F, F) -> F
and₂(T, B) -> B
and₂(B, T) -> B
and₂(F, B) -> F
and₂(B, F) -> F
imp₂(T, B) -> B
imp₂(F, B) -> T
not₁(T) -> F
not₁(F) -> T
if₃(T, B1, B2) -> B1
if₃(F, B1, B2) -> B2
eq₂(T, T) -> T
eq₂(F, F) -> T
eq₂(T, F) -> F
eq₂(F, T) -> F
eqt₂(nil, undefined) -> F
eqt₂(nil, pid₁(N2)) -> F
eqt₂(nil, int₁(N2)) -> F
eqt₂(nil, cons₂(H2, T2)) -> F
eqt₂(nil, tuple₂(H2, T2)) -> F
eqt₂(nil, tuplenil₁(H2)) -> F
eqt₂(a, nil) -> F
eqt₂(a, a) -> T
eqt₂(a, excl) -> F
eqt₂(a, false) -> F
eqt₂(a, lock) -> F
eqt₂(a, locker) -> F
eqt₂(a, mcrlrecord) -> F
eqt₂(a, ok) -> F
eqt₂(a, pending) -> F
eqt₂(a, release) -> F
eqt₂(a, request) -> F
eqt₂(a, resource) -> F
eqt₂(a, tag) -> F
eqt₂(a, true) -> F
eqt₂(a, undefined) -> F
eqt₂(a, pid₁(N2)) -> F
eqt₂(a, int₁(N2)) -> F
eqt₂(a, cons₂(H2, T2)) -> F
eqt₂(a, tuple₂(H2, T2)) -> F
eqt₂(a, tuplenil₁(H2)) -> F
eqt₂(excl, nil) -> F
eqt₂(excl, a) -> F
eqt₂(excl, excl) -> T
eqt₂(excl, false) -> F
eqt₂(excl, lock) -> F
eqt₂(excl, locker) -> F
eqt₂(excl, mcrlrecord) -> F
eqt₂(excl, ok) -> F
eqt₂(excl, pending) -> F
eqt₂(excl, release) -> F
eqt₂(excl, request) -> F
eqt₂(excl, resource) -> F
eqt₂(excl, tag) -> F
eqt₂(excl, true) -> F
eqt₂(excl, undefined) -> F
eqt₂(excl, pid₁(N2)) -> F
eqt₂(excl, eqt₂(false, int₁(N2))) -> F
eqt₂(false, cons₂(H2, T2)) -> F
eqt₂(false, tuple₂(H2, T2)) -> F
eqt₂(false, tuplenil₁(H2)) -> F
eqt₂(lock, nil) -> F
eqt₂(lock, a) -> F
eqt₂(lock, excl) -> F
eqt₂(lock, false) -> F
eqt₂(lock, lock) -> T
eqt₂(lock, locker) -> F
eqt₂(lock, mcrlrecord) -> F
eqt₂(lock, ok) -> F
eqt₂(lock, pending) -> F
eqt₂(lock, release) -> F
eqt₂(lock, request) -> F
eqt₂(lock, resource) -> F
eqt₂(lock, tag) -> F
eqt₂(lock, true) -> F
eqt₂(lock, undefined) -> F
eqt₂(lock, pid₁(N2)) -> F
eqt₂(lock, int₁(N2)) -> F
eqt₂(lock, cons₂(H2, T2)) -> F
eqt₂(lock, tuple₂(H2, T2)) -> F
eqt₂(lock, tuplenil₁(H2)) -> F
eqt₂(locker, nil) -> F
eqt₂(locker, a) -> F
eqt₂(locker, excl) -> F
eqt₂(locker, false) -> F
eqt₂(locker, lock) -> F
eqt₂(locker, locker) -> T
eqt₂(locker, mcrlrecord) -> F
eqt₂(locker, ok) -> F
eqt₂(locker, pending) -> F
eqt₂(locker, release) -> F
eqt₂(locker, request) -> F
eqt₂(locker, resource) -> F
eqt₂(locker, tag) -> F
eqt₂(locker, true) -> F
eqt₂(locker, undefined) -> F
eqt₂(locker, pid₁(N2)) -> F
eqt₂(locker, int₁(N2)) -> F
eqt₂(locker, cons₂(H2, T2)) -> F
eqt₂(locker, tuple₂(H2, T2)) -> F
eqt₂(locker, tuplenil₁(H2)) -> F
eqt₂(mcrlrecord, nil) -> F
eqt₂(mcrlrecord, a) -> F
eqt₂(mcrlrecord, excl) -> F
eqt₂(mcrlrecord, false) -> F
eqt₂(mcrlrecord, lock) -> F
eqt₂(mcrlrecord, locker) -> F
eqt₂(mcrlrecord, mcrlrecord) -> T
eqt₂(mcrlrecord, ok) -> F
eqt₂(mcrlrecord, pending) -> F
eqt₂(mcrlrecord, release) -> F
eqt₂(mcrlrecord, request) -> F
eqt₂(mcrlrecord, resource) -> F
eqt₂(ok, resource) -> F
eqt₂(ok, tag) -> F
eqt₂(ok, true) -> F
eqt₂(ok, undefined) -> F
eqt₂(ok, pid₁(N2)) -> F
eqt₂(ok, int₁(N2)) -> F
eqt₂(ok, cons₂(H2, T2)) -> F
eqt₂(ok, tuple₂(H2, T2)) -> F
eqt₂(ok, tuplenil₁(H2)) -> F
eqt₂(pending, nil) -> F
eqt₂(pending, a) -> F
eqt₂(pending, excl) -> F
eqt₂(pending, false) -> F
eqt₂(pending, lock) -> F
eqt₂(pending, locker) -> F
eqt₂(pending, mcrlrecord) -> F
eqt₂(pending, ok) -> F
eqt₂(pending, pending) -> T
eqt₂(pending, release) -> F
eqt₂(pending, request) -> F
eqt₂(pending, resource) -> F
eqt₂(pending, tag) -> F
eqt₂(pending, true) -> F
eqt₂(pending, undefined) -> F
eqt₂(pending, pid₁(N2)) -> F
eqt₂(pending, int₁(N2)) -> F
eqt₂(pending, cons₂(H2, T2)) -> F
eqt₂(pending, tuple₂(H2, T2)) -> F
eqt₂(pending, tuplenil₁(H2)) -> F
eqt₂(release, nil) -> F
eqt₂(release, a) -> F
eqt₂(release, excl) -> F
eqt₂(release, false) -> F
eqt₂(release, lock) -> F
eqt₂(release, locker) -> F
eqt₂(release, mcrlrecord) -> F
eqt₂(release, ok) -> F
eqt₂(request, mcrlrecord) -> F
eqt₂(request, ok) -> F
eqt₂(request, pending) -> F
eqt₂(request, release) -> F
eqt₂(request, request) -> T
eqt₂(request, resource) -> F
eqt₂(request, tag) -> F
eqt₂(request, true) -> F
eqt₂(request, undefined) -> F
eqt₂(request, pid₁(N2)) -> F
eqt₂(request, int₁(N2)) -> F
eqt₂(request, cons₂(H2, T2)) -> F
eqt₂(request, tuple₂(H2, T2)) -> F
eqt₂(request, tuplenil₁(H2)) -> F
eqt₂(resource, nil) -> F
eqt₂(resource, a) -> F
eqt₂(resource, excl) -> F
eqt₂(resource, false) -> F
eqt₂(resource, lock) -> F
eqt₂(resource, locker) -> F
eqt₂(resource, mcrlrecord) -> F
eqt₂(resource, ok) -> F
eqt₂(resource, pending) -> F
eqt₂(resource, release) -> F
eqt₂(resource, request) -> F
eqt₂(resource, resource) -> T
eqt₂(resource, tag) -> F
eqt₂(resource, true) -> F
eqt₂(resource, undefined) -> F
eqt₂(resource, pid₁(N2)) -> F
eqt₂(resource, int₁(N2)) -> F
eqt₂(resource, cons₂(H2, T2)) -> F
eqt₂(resource, tuple₂(H2, T2)) -> F
eqt₂(resource, tuplenil₁(H2)) -> F
eqt₂(tag, nil) -> F
eqt₂(tag, a) -> F
eqt₂(tag, excl) -> F
eqt₂(tag, false) -> F
eqt₂(tag, lock) -> F
eqt₂(tag, locker) -> F
eqt₂(tag, mcrlrecord) -> F
eqt₂(tag, ok) -> F
eqt₂(tag, pending) -> F
eqt₂(tag, release) -> F
eqt₂(tag, request) -> F
eqt₂(tag, resource) -> F
eqt₂(tag, tag) -> T
eqt₂(tag, true) -> F
eqt₂(tag, undefined) -> F
eqt₂(tag, pid₁(N2)) -> F
eqt₂(tag, int₁(N2)) -> F
eqt₂(tag, cons₂(H2, T2)) -> F
eqt₂(tag, tuple₂(H2, T2)) -> F
eqt₂(tag, tuplenil₁(H2)) -> F
eqt₂(true, nil) -> F
eqt₂(true, a) -> F
eqt₂(true, excl) -> F
eqt₂(true, false) -> F
eqt₂(true, lock) -> F
eqt₂(true, locker) -> F
eqt₂(true, mcrlrecord) -> F
eqt₂(true, ok) -> F
eqt₂(true, pending) -> F
eqt₂(true, release) -> F
eqt₂(true, request) -> F
eqt₂(true, resource) -> F
eqt₂(true, tag) -> F
eqt₂(true, true) -> T
eqt₂(true, undefined) -> F
eqt₂(true, pid₁(N2)) -> F
eqt₂(true, int₁(N2)) -> F
eqt₂(true, cons₂(H2, T2)) -> F
eqt₂(true, tuple₂(H2, T2)) -> F
eqt₂(true, tuplenil₁(H2)) -> F
eqt₂(undefined, nil) -> F
eqt₂(undefined, a) -> F
eqt₂(undefined, tuplenil₁(H2)) -> F
eqt₂(pid₁(N1), nil) -> F
eqt₂(pid₁(N1), a) -> F
eqt₂(pid₁(N1), excl) -> F
eqt₂(pid₁(N1), false) -> F
eqt₂(pid₁(N1), lock) -> F
eqt₂(pid₁(N1), locker) -> F
eqt₂(pid₁(N1), mcrlrecord) -> F
eqt₂(pid₁(N1), ok) -> F
eqt₂(pid₁(N1), pending) -> F
eqt₂(pid₁(N1), release) -> F
eqt₂(pid₁(N1), request) -> F
eqt₂(pid₁(N1), resource) -> F
eqt₂(pid₁(N1), tag) -> F
eqt₂(pid₁(N1), true) -> F
eqt₂(pid₁(N1), undefined) -> F
eqt₂(pid₁(N1), pid₁(N2)) -> eqt₂(N1, N2)
eqt₂(pid₁(N1), int₁(N2)) -> F
eqt₂(pid₁(N1), cons₂(H2, T2)) -> F
eqt₂(pid₁(N1), tuple₂(H2, T2)) -> F
eqt₂(pid₁(N1), tuplenil₁(H2)) -> F
eqt₂(int₁(N1), nil) -> F
eqt₂(int₁(N1), a) -> F
eqt₂(int₁(N1), excl) -> F
eqt₂(int₁(N1), false) -> F
eqt₂(int₁(N1), lock) -> F
eqt₂(int₁(N1), locker) -> F
eqt₂(int₁(N1), mcrlrecord) -> F
eqt₂(int₁(N1), ok) -> F
eqt₂(int₁(N1), pending) -> F
eqt₂(int₁(N1), release) -> F
eqt₂(int₁(N1), request) -> F
eqt₂(int₁(N1), resource) -> F
eqt₂(int₁(N1), tag) -> F
eqt₂(int₁(N1), true) -> F
eqt₂(int₁(N1), undefined) -> F
eqt₂(cons₂(H1, T1), resource) -> F
eqt₂(cons₂(H1, T1), tag) -> F
eqt₂(cons₂(H1, T1), true) -> F
eqt₂(cons₂(H1, T1), undefined) -> F
eqt₂(cons₂(H1, T1), pid₁(N2)) -> F
eqt₂(cons₂(H1, T1), int₁(N2)) -> F
eqt₂(cons₂(H1, T1), cons₂(H2, T2)) -> and₂(eqt₂(H1, H2), eqt₂(T1, T2))
eqt₂(cons₂(H1, T1), tuple₂(H2, T2)) -> F
eqt₂(cons₂(H1, T1), tuplenil₁(H2)) -> F
eqt₂(tuple₂(H1, T1), nil) -> F
eqt₂(tuple₂(H1, T1), a) -> F
eqt₂(tuple₂(H1, T1), excl) -> F
eqt₂(tuple₂(H1, T1), false) -> F
eqt₂(tuple₂(H1, T1), lock) -> F
eqt₂(tuple₂(H1, T1), locker) -> F
eqt₂(tuple₂(H1, T1), mcrlrecord) -> F
eqt₂(tuple₂(H1, T1), ok) -> F
eqt₂(tuple₂(H1, T1), pending) -> F
eqt₂(tuple₂(H1, T1), release) -> F
eqt₂(tuple₂(H1, T1), request) -> F
eqt₂(tuple₂(H1, T1), resource) -> F
eqt₂(tuple₂(H1, T1), tag) -> F
eqt₂(tuple₂(H1, T1), true) -> F
eqt₂(tuple₂(H1, T1), undefined) -> F
eqt₂(tuple₂(H1, T1), pid₁(N2)) -> F
eqt₂(tuple₂(H1, T1), int₁(N2)) -> F
eqt₂(tuple₂(H1, T1), cons₂(H2, T2)) -> F
eqt₂(tuple₂(H1, T1), tuple₂(H2, T2)) -> and₂(eqt₂(H1, H2), eqt₂(T1, T2))
eqt₂(tuple₂(H1, T1), tuplenil₁(H2)) -> F
eqt₂(tuplenil₁(H1), nil) -> F
eqt₂(tuplenil₁(H1), a) -> F
eqt₂(tuplenil₁(H1), excl) -> F
eqt₂(tuplenil₁(H1), false) -> F
eqt₂(tuplenil₁(H1), lock) -> F
eqt₂(tuplenil₁(H1), locker) -> F
eqt₂(tuplenil₁(H1), mcrlrecord) -> F
eqt₂(tuplenil₁(H1), ok) -> F
eqt₂(tuplenil₁(H1), pending) -> F
eqt₂(tuplenil₁(H1), release) -> F
eqt₂(tuplenil₁(H1), request) -> F
eqt₂(tuplenil₁(H1), resource) -> F
eqt₂(tuplenil₁(H1), tag) -> F
eqt₂(tuplenil₁(H1), true) -> F
eqt₂(tuplenil₁(H1), undefined) -> F
eqt₂(tuplenil₁(H1), pid₁(N2)) -> F
eqt₂(tuplenil₁(H1), int₁(N2)) -> F
eqt₂(tuplenil₁(H1), cons₂(H2, T2)) -> F
eqt₂(tuplenil₁(H1), tuple₂(H2, T2)) -> F
eqt₂(tuplenil₁(H1), tuplenil₁(H2)) -> eqt₂(H1, H2)
element₂(int₁(s₁(0)), tuplenil₁(T1)) -> T1
element₂(int₁(s₁(0)), tuple₂(T1, T2)) -> T1
element₂(int₁(s₁(s₁(N1))), tuple₂(T1, T2)) -> element₂(int₁(s₁(N1)), T2)
record_new₁(lock) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(undefined, tuple₂(nil, tuplenil₁(nil)))))
record_extract₃(tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2))))), lock, resource) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2)))))
record_update₄(tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2))))), lock, pending, NewF) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(NewF)))))
record_updates₃(Record, Name, nil) -> Record
record_updates₃(Record, Name, cons₂(tuple₂(Field, tuplenil₁(NewF)), Fields)) -> record_updates₃(record_update₄(Record, Name, Field, NewF), Name, Fields)
locker2_map_promote_pending₂(nil, Pending) -> nil
locker2_map_promote_pending₂(cons₂(Lock, Locks), Pending) -> cons₂(locker2_promote_pending₂(Lock, Pending), locker2_map_promote_pending₂(Locks, Pending))
locker2_map_claim_lock₃(nil, Resources, Client) -> nil
locker2_map_claim_lock₃(cons₂(Lock, Locks), Resources, Client) -> cons₂(locker2_claim_lock₃(Lock, Resources, Client), locker2_map_claim_lock₃(Locks, Resources, Client))
locker2_map_add_pending₃(nil, Resources, Client) -> nil
locker2_promote_pending₂(Lock, Client) -> case0₃(Client, Lock, record_extract₃(Lock, lock, pending))
case0₃(Client, Lock, cons₂(Client, Pendings)) -> record_updates₃(Lock, lock, cons₂(tuple₂(excl, tuplenil₁(Client)), cons₂(tuple₂(pending, tuplenil₁(Pendings)), nil)))
case0₃(Client, Lock, MCRLFree0) -> Lock
locker2_remove_pending₂(Lock, Client) -> record_updates₃(Lock, lock, cons₂(tuple₂(pending, tuplenil₁(subtract₂(record_extract₃(Lock, lock, pending), cons₂(Client, nil)))), nil))
locker2_add_pending₃(Lock, Resources, Client) -> case1₄(Client, Resources, Lock, member₂(record_extract₃(Lock, lock, resource), Resources))
case1₄(Client, Resources, Lock, true) -> record_updates₃(Lock, lock, cons₂(tuple₂(pending, tuplenil₁(append₂(record_extract₃(Lock, lock, pending), cons₂(Client, nil)))), nil))
case1₄(Client, Resources, Lock, false) -> Lock
locker2_release_lock₂(Lock, Client) -> case2₃(Client, Lock, gen_modtageq₂(Client, record_extract₃(Lock, lock, excl)))
case2₃(Client, Lock, true) -> record_updates₃(Lock, lock, cons₂(tuple₂(excllock, excl), nil))
case4₃(Client, Lock, MCRLFree1) -> false
locker2_obtainables₂(nil, Client) -> true
locker2_obtainables₂(cons₂(Lock, Locks), Client) -> case5₄(Client, Locks, Lock, member₂(Client, record_extract₃(Lock, lock, pending)))
case5₄(Client, Locks, Lock, true) -> andt₂(locker2_obtainable₂(Lock, Client), locker2_obtainables₂(Locks, Client))
case5₄(Client, Locks, Lock, false) -> locker2_obtainables₂(Locks, Client)
locker2_check_available₂(Resource, nil) -> false
locker2_check_available₂(Resource, cons₂(Lock, Locks)) -> case6₄(Locks, Lock, Resource, equal₂(Resource, record_extract₃(Lock, lock, resource)))
case6₄(Locks, Lock, Resource, true) -> andt₂(equal₂(record_extract₃(Lock, lock, excl), nil), equal₂(record_extract₃(Lock, lock, pending), nil))
case6₄(Locks, Lock, Resource, false) -> locker2_check_available₂(Resource, Locks)
locker2_check_availables₂(nil, Locks) -> true
locker2_check_availables₂(cons₂(Resource, Resources), Locks) -> andt₂(locker2_check_available₂(Resource, Locks), locker2_check_availables₂(Resources, Locks))
locker2_adduniq₂(nil, List) -> List
append₂(cons₂(Head, Tail), List) -> cons₂(Head, append₂(Tail, List))
subtract₂(List, nil) -> List
subtract₂(List, cons₂(Head, Tail)) -> subtract₂(delete₂(Head, List), Tail)
delete₂(E, nil) -> nil
delete₂(E, cons₂(Head, Tail)) -> case8₄(Tail, Head, E, equal₂(E, Head))
case8₄(Tail, Head, E, true) -> Tail
case8₄(Tail, Head, E, false) -> cons₂(Head, delete₂(E, Tail))
gen_tag₁(Pid) -> tuple₂(Pid, tuplenil₁(tag))
gen_modtageq₂(Client1, Client2) -> equal₂(Client1, Client2)
member₂(E, nil) -> false
member₂(E, cons₂(Head, Tail)) -> case9₄(Tail, Head, E, equal₂(E, Head))
case9₄(Tail, Head, E, true) -> true
case9₄(Tail, Head, E, false) -> member₂(E, Tail)
eqs₂(empty, empty) -> T
eqs₂(empty, stack₂(E2, S2)) -> F
eqs₂(stack₂(E1, S1), empty) -> F
eqs₂(stack₂(E1, S1), stack₂(E2, S2)) -> and₂(eqt₂(E1, E2), eqs₂(S1, S2))
pushs₂(E1, S1) -> stack₂(E1, S1)
pops₁(stack₂(E1, S1)) -> S1
tops₁(stack₂(E1, S1)) -> E1
istops₂(E1, empty) -> F
istops₂(E1, stack₂(E2, S1)) -> eqt₂(E1, E2)
eqc₂(nocalls, nocalls) -> T
eqc₂(nocalls, calls₃(E2, S2, CS2)) -> F
eqc₂(calls₃(E1, S1, CS1), nocalls) -> F
eqc₂(calls₃(E1, S1, CS1), calls₃(E2, S2, CS2)) -> and₂(eqt₂(E1, E2), and₂(eqs₂(S1, S2), eqc₂(CS1, CS2)))
push₃(E1, E2, nocalls) -> calls₃(E1, stack₂(E2, empty), nocalls)
push₃(E1, E2, calls₃(E3, S1, CS1)) -> push1₆(E1, E2, E3, S1, CS1, eqt₂(E1, E3))
push1₆(E1, E2, E3, S1, CS1, T) -> calls₃(E3, pushs₂(E2, S1), CS1)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [13,14,18] contains 10 SCCs with 46 less nodes.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

SUBTRACT₂(List, cons₂(Head, Tail)) -> SUBTRACT₂(delete₂(Head, List), Tail)

The TRS R consists of the following rules:

or₂(T, T) -> T
or₂(F, T) -> T
or₂(T, F) -> T
or₂(F, F) -> F
and₂(T, B) -> B
and₂(B, T) -> B
and₂(F, B) -> F
and₂(B, F) -> F
imp₂(T, B) -> B
imp₂(F, B) -> T
not₁(T) -> F
not₁(F) -> T
if₃(T, B1, B2) -> B1
if₃(F, B1, B2) -> B2
eq₂(T, T) -> T
eq₂(F, F) -> T
eq₂(T, F) -> F
eq₂(F, T) -> F
eqt₂(nil, undefined) -> F
eqt₂(nil, pid₁(N2)) -> F
eqt₂(nil, int₁(N2)) -> F
eqt₂(nil, cons₂(H2, T2)) -> F
eqt₂(nil, tuple₂(H2, T2)) -> F
eqt₂(nil, tuplenil₁(H2)) -> F
eqt₂(a, nil) -> F
eqt₂(a, a) -> T
eqt₂(a, excl) -> F
eqt₂(a, false) -> F
eqt₂(a, lock) -> F
eqt₂(a, locker) -> F
eqt₂(a, mcrlrecord) -> F
eqt₂(a, ok) -> F
eqt₂(a, pending) -> F
eqt₂(a, release) -> F
eqt₂(a, request) -> F
eqt₂(a, resource) -> F
eqt₂(a, tag) -> F
eqt₂(a, true) -> F
eqt₂(a, undefined) -> F
eqt₂(a, pid₁(N2)) -> F
eqt₂(a, int₁(N2)) -> F
eqt₂(a, cons₂(H2, T2)) -> F
eqt₂(a, tuple₂(H2, T2)) -> F
eqt₂(a, tuplenil₁(H2)) -> F
eqt₂(excl, nil) -> F
eqt₂(excl, a) -> F
eqt₂(excl, excl) -> T
eqt₂(excl, false) -> F
eqt₂(excl, lock) -> F
eqt₂(excl, locker) -> F
eqt₂(excl, mcrlrecord) -> F
eqt₂(excl, ok) -> F
eqt₂(excl, pending) -> F
eqt₂(excl, release) -> F
eqt₂(excl, request) -> F
eqt₂(excl, resource) -> F
eqt₂(excl, tag) -> F
eqt₂(excl, true) -> F
eqt₂(excl, undefined) -> F
eqt₂(excl, pid₁(N2)) -> F
eqt₂(excl, eqt₂(false, int₁(N2))) -> F
eqt₂(false, cons₂(H2, T2)) -> F
eqt₂(false, tuple₂(H2, T2)) -> F
eqt₂(false, tuplenil₁(H2)) -> F
eqt₂(lock, nil) -> F
eqt₂(lock, a) -> F
eqt₂(lock, excl) -> F
eqt₂(lock, false) -> F
eqt₂(lock, lock) -> T
eqt₂(lock, locker) -> F
eqt₂(lock, mcrlrecord) -> F
eqt₂(lock, ok) -> F
eqt₂(lock, pending) -> F
eqt₂(lock, release) -> F
eqt₂(lock, request) -> F
eqt₂(lock, resource) -> F
eqt₂(lock, tag) -> F
eqt₂(lock, true) -> F
eqt₂(lock, undefined) -> F
eqt₂(lock, pid₁(N2)) -> F
eqt₂(lock, int₁(N2)) -> F
eqt₂(lock, cons₂(H2, T2)) -> F
eqt₂(lock, tuple₂(H2, T2)) -> F
eqt₂(lock, tuplenil₁(H2)) -> F
eqt₂(locker, nil) -> F
eqt₂(locker, a) -> F
eqt₂(locker, excl) -> F
eqt₂(locker, false) -> F
eqt₂(locker, lock) -> F
eqt₂(locker, locker) -> T
eqt₂(locker, mcrlrecord) -> F
eqt₂(locker, ok) -> F
eqt₂(locker, pending) -> F
eqt₂(locker, release) -> F
eqt₂(locker, request) -> F
eqt₂(locker, resource) -> F
eqt₂(locker, tag) -> F
eqt₂(locker, true) -> F
eqt₂(locker, undefined) -> F
eqt₂(locker, pid₁(N2)) -> F
eqt₂(locker, int₁(N2)) -> F
eqt₂(locker, cons₂(H2, T2)) -> F
eqt₂(locker, tuple₂(H2, T2)) -> F
eqt₂(locker, tuplenil₁(H2)) -> F
eqt₂(mcrlrecord, nil) -> F
eqt₂(mcrlrecord, a) -> F
eqt₂(mcrlrecord, excl) -> F
eqt₂(mcrlrecord, false) -> F
eqt₂(mcrlrecord, lock) -> F
eqt₂(mcrlrecord, locker) -> F
eqt₂(mcrlrecord, mcrlrecord) -> T
eqt₂(mcrlrecord, ok) -> F
eqt₂(mcrlrecord, pending) -> F
eqt₂(mcrlrecord, release) -> F
eqt₂(mcrlrecord, request) -> F
eqt₂(mcrlrecord, resource) -> F
eqt₂(ok, resource) -> F
eqt₂(ok, tag) -> F
eqt₂(ok, true) -> F
eqt₂(ok, undefined) -> F
eqt₂(ok, pid₁(N2)) -> F
eqt₂(ok, int₁(N2)) -> F
eqt₂(ok, cons₂(H2, T2)) -> F
eqt₂(ok, tuple₂(H2, T2)) -> F
eqt₂(ok, tuplenil₁(H2)) -> F
eqt₂(pending, nil) -> F
eqt₂(pending, a) -> F
eqt₂(pending, excl) -> F
eqt₂(pending, false) -> F
eqt₂(pending, lock) -> F
eqt₂(pending, locker) -> F
eqt₂(pending, mcrlrecord) -> F
eqt₂(pending, ok) -> F
eqt₂(pending, pending) -> T
eqt₂(pending, release) -> F
eqt₂(pending, request) -> F
eqt₂(pending, resource) -> F
eqt₂(pending, tag) -> F
eqt₂(pending, true) -> F
eqt₂(pending, undefined) -> F
eqt₂(pending, pid₁(N2)) -> F
eqt₂(pending, int₁(N2)) -> F
eqt₂(pending, cons₂(H2, T2)) -> F
eqt₂(pending, tuple₂(H2, T2)) -> F
eqt₂(pending, tuplenil₁(H2)) -> F
eqt₂(release, nil) -> F
eqt₂(release, a) -> F
eqt₂(release, excl) -> F
eqt₂(release, false) -> F
eqt₂(release, lock) -> F
eqt₂(release, locker) -> F
eqt₂(release, mcrlrecord) -> F
eqt₂(release, ok) -> F
eqt₂(request, mcrlrecord) -> F
eqt₂(request, ok) -> F
eqt₂(request, pending) -> F
eqt₂(request, release) -> F
eqt₂(request, request) -> T
eqt₂(request, resource) -> F
eqt₂(request, tag) -> F
eqt₂(request, true) -> F
eqt₂(request, undefined) -> F
eqt₂(request, pid₁(N2)) -> F
eqt₂(request, int₁(N2)) -> F
eqt₂(request, cons₂(H2, T2)) -> F
eqt₂(request, tuple₂(H2, T2)) -> F
eqt₂(request, tuplenil₁(H2)) -> F
eqt₂(resource, nil) -> F
eqt₂(resource, a) -> F
eqt₂(resource, excl) -> F
eqt₂(resource, false) -> F
eqt₂(resource, lock) -> F
eqt₂(resource, locker) -> F
eqt₂(resource, mcrlrecord) -> F
eqt₂(resource, ok) -> F
eqt₂(resource, pending) -> F
eqt₂(resource, release) -> F
eqt₂(resource, request) -> F
eqt₂(resource, resource) -> T
eqt₂(resource, tag) -> F
eqt₂(resource, true) -> F
eqt₂(resource, undefined) -> F
eqt₂(resource, pid₁(N2)) -> F
eqt₂(resource, int₁(N2)) -> F
eqt₂(resource, cons₂(H2, T2)) -> F
eqt₂(resource, tuple₂(H2, T2)) -> F
eqt₂(resource, tuplenil₁(H2)) -> F
eqt₂(tag, nil) -> F
eqt₂(tag, a) -> F
eqt₂(tag, excl) -> F
eqt₂(tag, false) -> F
eqt₂(tag, lock) -> F
eqt₂(tag, locker) -> F
eqt₂(tag, mcrlrecord) -> F
eqt₂(tag, ok) -> F
eqt₂(tag, pending) -> F
eqt₂(tag, release) -> F
eqt₂(tag, request) -> F
eqt₂(tag, resource) -> F
eqt₂(tag, tag) -> T
eqt₂(tag, true) -> F
eqt₂(tag, undefined) -> F
eqt₂(tag, pid₁(N2)) -> F
eqt₂(tag, int₁(N2)) -> F
eqt₂(tag, cons₂(H2, T2)) -> F
eqt₂(tag, tuple₂(H2, T2)) -> F
eqt₂(tag, tuplenil₁(H2)) -> F
eqt₂(true, nil) -> F
eqt₂(true, a) -> F
eqt₂(true, excl) -> F
eqt₂(true, false) -> F
eqt₂(true, lock) -> F
eqt₂(true, locker) -> F
eqt₂(true, mcrlrecord) -> F
eqt₂(true, ok) -> F
eqt₂(true, pending) -> F
eqt₂(true, release) -> F
eqt₂(true, request) -> F
eqt₂(true, resource) -> F
eqt₂(true, tag) -> F
eqt₂(true, true) -> T
eqt₂(true, undefined) -> F
eqt₂(true, pid₁(N2)) -> F
eqt₂(true, int₁(N2)) -> F
eqt₂(true, cons₂(H2, T2)) -> F
eqt₂(true, tuple₂(H2, T2)) -> F
eqt₂(true, tuplenil₁(H2)) -> F
eqt₂(undefined, nil) -> F
eqt₂(undefined, a) -> F
eqt₂(undefined, tuplenil₁(H2)) -> F
eqt₂(pid₁(N1), nil) -> F
eqt₂(pid₁(N1), a) -> F
eqt₂(pid₁(N1), excl) -> F
eqt₂(pid₁(N1), false) -> F
eqt₂(pid₁(N1), lock) -> F
eqt₂(pid₁(N1), locker) -> F
eqt₂(pid₁(N1), mcrlrecord) -> F
eqt₂(pid₁(N1), ok) -> F
eqt₂(pid₁(N1), pending) -> F
eqt₂(pid₁(N1), release) -> F
eqt₂(pid₁(N1), request) -> F
eqt₂(pid₁(N1), resource) -> F
eqt₂(pid₁(N1), tag) -> F
eqt₂(pid₁(N1), true) -> F
eqt₂(pid₁(N1), undefined) -> F
eqt₂(pid₁(N1), pid₁(N2)) -> eqt₂(N1, N2)
eqt₂(pid₁(N1), int₁(N2)) -> F
eqt₂(pid₁(N1), cons₂(H2, T2)) -> F
eqt₂(pid₁(N1), tuple₂(H2, T2)) -> F
eqt₂(pid₁(N1), tuplenil₁(H2)) -> F
eqt₂(int₁(N1), nil) -> F
eqt₂(int₁(N1), a) -> F
eqt₂(int₁(N1), excl) -> F
eqt₂(int₁(N1), false) -> F
eqt₂(int₁(N1), lock) -> F
eqt₂(int₁(N1), locker) -> F
eqt₂(int₁(N1), mcrlrecord) -> F
eqt₂(int₁(N1), ok) -> F
eqt₂(int₁(N1), pending) -> F
eqt₂(int₁(N1), release) -> F
eqt₂(int₁(N1), request) -> F
eqt₂(int₁(N1), resource) -> F
eqt₂(int₁(N1), tag) -> F
eqt₂(int₁(N1), true) -> F
eqt₂(int₁(N1), undefined) -> F
eqt₂(cons₂(H1, T1), resource) -> F
eqt₂(cons₂(H1, T1), tag) -> F
eqt₂(cons₂(H1, T1), true) -> F
eqt₂(cons₂(H1, T1), undefined) -> F
eqt₂(cons₂(H1, T1), pid₁(N2)) -> F
eqt₂(cons₂(H1, T1), int₁(N2)) -> F
eqt₂(cons₂(H1, T1), cons₂(H2, T2)) -> and₂(eqt₂(H1, H2), eqt₂(T1, T2))
eqt₂(cons₂(H1, T1), tuple₂(H2, T2)) -> F
eqt₂(cons₂(H1, T1), tuplenil₁(H2)) -> F
eqt₂(tuple₂(H1, T1), nil) -> F
eqt₂(tuple₂(H1, T1), a) -> F
eqt₂(tuple₂(H1, T1), excl) -> F
eqt₂(tuple₂(H1, T1), false) -> F
eqt₂(tuple₂(H1, T1), lock) -> F
eqt₂(tuple₂(H1, T1), locker) -> F
eqt₂(tuple₂(H1, T1), mcrlrecord) -> F
eqt₂(tuple₂(H1, T1), ok) -> F
eqt₂(tuple₂(H1, T1), pending) -> F
eqt₂(tuple₂(H1, T1), release) -> F
eqt₂(tuple₂(H1, T1), request) -> F
eqt₂(tuple₂(H1, T1), resource) -> F
eqt₂(tuple₂(H1, T1), tag) -> F
eqt₂(tuple₂(H1, T1), true) -> F
eqt₂(tuple₂(H1, T1), undefined) -> F
eqt₂(tuple₂(H1, T1), pid₁(N2)) -> F
eqt₂(tuple₂(H1, T1), int₁(N2)) -> F
eqt₂(tuple₂(H1, T1), cons₂(H2, T2)) -> F
eqt₂(tuple₂(H1, T1), tuple₂(H2, T2)) -> and₂(eqt₂(H1, H2), eqt₂(T1, T2))
eqt₂(tuple₂(H1, T1), tuplenil₁(H2)) -> F
eqt₂(tuplenil₁(H1), nil) -> F
eqt₂(tuplenil₁(H1), a) -> F
eqt₂(tuplenil₁(H1), excl) -> F
eqt₂(tuplenil₁(H1), false) -> F
eqt₂(tuplenil₁(H1), lock) -> F
eqt₂(tuplenil₁(H1), locker) -> F
eqt₂(tuplenil₁(H1), mcrlrecord) -> F
eqt₂(tuplenil₁(H1), ok) -> F
eqt₂(tuplenil₁(H1), pending) -> F
eqt₂(tuplenil₁(H1), release) -> F
eqt₂(tuplenil₁(H1), request) -> F
eqt₂(tuplenil₁(H1), resource) -> F
eqt₂(tuplenil₁(H1), tag) -> F
eqt₂(tuplenil₁(H1), true) -> F
eqt₂(tuplenil₁(H1), undefined) -> F
eqt₂(tuplenil₁(H1), pid₁(N2)) -> F
eqt₂(tuplenil₁(H1), int₁(N2)) -> F
eqt₂(tuplenil₁(H1), cons₂(H2, T2)) -> F
eqt₂(tuplenil₁(H1), tuple₂(H2, T2)) -> F
eqt₂(tuplenil₁(H1), tuplenil₁(H2)) -> eqt₂(H1, H2)
element₂(int₁(s₁(0)), tuplenil₁(T1)) -> T1
element₂(int₁(s₁(0)), tuple₂(T1, T2)) -> T1
element₂(int₁(s₁(s₁(N1))), tuple₂(T1, T2)) -> element₂(int₁(s₁(N1)), T2)
record_new₁(lock) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(undefined, tuple₂(nil, tuplenil₁(nil)))))
record_extract₃(tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2))))), lock, resource) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2)))))
record_update₄(tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2))))), lock, pending, NewF) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(NewF)))))
record_updates₃(Record, Name, nil) -> Record
record_updates₃(Record, Name, cons₂(tuple₂(Field, tuplenil₁(NewF)), Fields)) -> record_updates₃(record_update₄(Record, Name, Field, NewF), Name, Fields)
locker2_map_promote_pending₂(nil, Pending) -> nil
locker2_map_promote_pending₂(cons₂(Lock, Locks), Pending) -> cons₂(locker2_promote_pending₂(Lock, Pending), locker2_map_promote_pending₂(Locks, Pending))
locker2_map_claim_lock₃(nil, Resources, Client) -> nil
locker2_map_claim_lock₃(cons₂(Lock, Locks), Resources, Client) -> cons₂(locker2_claim_lock₃(Lock, Resources, Client), locker2_map_claim_lock₃(Locks, Resources, Client))
locker2_map_add_pending₃(nil, Resources, Client) -> nil
locker2_promote_pending₂(Lock, Client) -> case0₃(Client, Lock, record_extract₃(Lock, lock, pending))
case0₃(Client, Lock, cons₂(Client, Pendings)) -> record_updates₃(Lock, lock, cons₂(tuple₂(excl, tuplenil₁(Client)), cons₂(tuple₂(pending, tuplenil₁(Pendings)), nil)))
case0₃(Client, Lock, MCRLFree0) -> Lock
locker2_remove_pending₂(Lock, Client) -> record_updates₃(Lock, lock, cons₂(tuple₂(pending, tuplenil₁(subtract₂(record_extract₃(Lock, lock, pending), cons₂(Client, nil)))), nil))
locker2_add_pending₃(Lock, Resources, Client) -> case1₄(Client, Resources, Lock, member₂(record_extract₃(Lock, lock, resource), Resources))
case1₄(Client, Resources, Lock, true) -> record_updates₃(Lock, lock, cons₂(tuple₂(pending, tuplenil₁(append₂(record_extract₃(Lock, lock, pending), cons₂(Client, nil)))), nil))
case1₄(Client, Resources, Lock, false) -> Lock
locker2_release_lock₂(Lock, Client) -> case2₃(Client, Lock, gen_modtageq₂(Client, record_extract₃(Lock, lock, excl)))
case2₃(Client, Lock, true) -> record_updates₃(Lock, lock, cons₂(tuple₂(excllock, excl), nil))
case4₃(Client, Lock, MCRLFree1) -> false
locker2_obtainables₂(nil, Client) -> true
locker2_obtainables₂(cons₂(Lock, Locks), Client) -> case5₄(Client, Locks, Lock, member₂(Client, record_extract₃(Lock, lock, pending)))
case5₄(Client, Locks, Lock, true) -> andt₂(locker2_obtainable₂(Lock, Client), locker2_obtainables₂(Locks, Client))
case5₄(Client, Locks, Lock, false) -> locker2_obtainables₂(Locks, Client)
locker2_check_available₂(Resource, nil) -> false
locker2_check_available₂(Resource, cons₂(Lock, Locks)) -> case6₄(Locks, Lock, Resource, equal₂(Resource, record_extract₃(Lock, lock, resource)))
case6₄(Locks, Lock, Resource, true) -> andt₂(equal₂(record_extract₃(Lock, lock, excl), nil), equal₂(record_extract₃(Lock, lock, pending), nil))
case6₄(Locks, Lock, Resource, false) -> locker2_check_available₂(Resource, Locks)
locker2_check_availables₂(nil, Locks) -> true
locker2_check_availables₂(cons₂(Resource, Resources), Locks) -> andt₂(locker2_check_available₂(Resource, Locks), locker2_check_availables₂(Resources, Locks))
locker2_adduniq₂(nil, List) -> List
append₂(cons₂(Head, Tail), List) -> cons₂(Head, append₂(Tail, List))
subtract₂(List, nil) -> List
subtract₂(List, cons₂(Head, Tail)) -> subtract₂(delete₂(Head, List), Tail)
delete₂(E, nil) -> nil
delete₂(E, cons₂(Head, Tail)) -> case8₄(Tail, Head, E, equal₂(E, Head))
case8₄(Tail, Head, E, true) -> Tail
case8₄(Tail, Head, E, false) -> cons₂(Head, delete₂(E, Tail))
gen_tag₁(Pid) -> tuple₂(Pid, tuplenil₁(tag))
gen_modtageq₂(Client1, Client2) -> equal₂(Client1, Client2)
member₂(E, nil) -> false
member₂(E, cons₂(Head, Tail)) -> case9₄(Tail, Head, E, equal₂(E, Head))
case9₄(Tail, Head, E, true) -> true
case9₄(Tail, Head, E, false) -> member₂(E, Tail)
eqs₂(empty, empty) -> T
eqs₂(empty, stack₂(E2, S2)) -> F
eqs₂(stack₂(E1, S1), empty) -> F
eqs₂(stack₂(E1, S1), stack₂(E2, S2)) -> and₂(eqt₂(E1, E2), eqs₂(S1, S2))
pushs₂(E1, S1) -> stack₂(E1, S1)
pops₁(stack₂(E1, S1)) -> S1
tops₁(stack₂(E1, S1)) -> E1
istops₂(E1, empty) -> F
istops₂(E1, stack₂(E2, S1)) -> eqt₂(E1, E2)
eqc₂(nocalls, nocalls) -> T
eqc₂(nocalls, calls₃(E2, S2, CS2)) -> F
eqc₂(calls₃(E1, S1, CS1), nocalls) -> F
eqc₂(calls₃(E1, S1, CS1), calls₃(E2, S2, CS2)) -> and₂(eqt₂(E1, E2), and₂(eqs₂(S1, S2), eqc₂(CS1, CS2)))
push₃(E1, E2, nocalls) -> calls₃(E1, stack₂(E2, empty), nocalls)
push₃(E1, E2, calls₃(E3, S1, CS1)) -> push1₆(E1, E2, E3, S1, CS1, eqt₂(E1, E3))
push1₆(E1, E2, E3, S1, CS1, T) -> calls₃(E3, pushs₂(E2, S1), CS1)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

SUBTRACT₂(List, cons₂(Head, Tail)) -> SUBTRACT₂(delete₂(Head, List), Tail)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial Order [17,21] with Interpretation:

POL( delete₂(x₁, x₂) ) = max{0, -1}

POL( SUBTRACT₂(x₁, x₂) ) = x₁ + x₂

POL( nil ) = max{0, -1}

POL( case8₄(x₁, ..., x₄) ) = max{0, -1}

POL( cons₂(x₁, x₂) ) = x₁ + x₂ + 1

POL( equal₂(x₁, x₂) ) = max{0, -1}

The following usable rules [14] were oriented:

delete₂(E, nil) -> nil
delete₂(E, cons₂(Head, Tail)) -> case8₄(Tail, Head, E, equal₂(E, Head))

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

or₂(T, T) -> T
or₂(F, T) -> T
or₂(T, F) -> T
or₂(F, F) -> F
and₂(T, B) -> B
and₂(B, T) -> B
and₂(F, B) -> F
and₂(B, F) -> F
imp₂(T, B) -> B
imp₂(F, B) -> T
not₁(T) -> F
not₁(F) -> T
if₃(T, B1, B2) -> B1
if₃(F, B1, B2) -> B2
eq₂(T, T) -> T
eq₂(F, F) -> T
eq₂(T, F) -> F
eq₂(F, T) -> F
eqt₂(nil, undefined) -> F
eqt₂(nil, pid₁(N2)) -> F
eqt₂(nil, int₁(N2)) -> F
eqt₂(nil, cons₂(H2, T2)) -> F
eqt₂(nil, tuple₂(H2, T2)) -> F
eqt₂(nil, tuplenil₁(H2)) -> F
eqt₂(a, nil) -> F
eqt₂(a, a) -> T
eqt₂(a, excl) -> F
eqt₂(a, false) -> F
eqt₂(a, lock) -> F
eqt₂(a, locker) -> F
eqt₂(a, mcrlrecord) -> F
eqt₂(a, ok) -> F
eqt₂(a, pending) -> F
eqt₂(a, release) -> F
eqt₂(a, request) -> F
eqt₂(a, resource) -> F
eqt₂(a, tag) -> F
eqt₂(a, true) -> F
eqt₂(a, undefined) -> F
eqt₂(a, pid₁(N2)) -> F
eqt₂(a, int₁(N2)) -> F
eqt₂(a, cons₂(H2, T2)) -> F
eqt₂(a, tuple₂(H2, T2)) -> F
eqt₂(a, tuplenil₁(H2)) -> F
eqt₂(excl, nil) -> F
eqt₂(excl, a) -> F
eqt₂(excl, excl) -> T
eqt₂(excl, false) -> F
eqt₂(excl, lock) -> F
eqt₂(excl, locker) -> F
eqt₂(excl, mcrlrecord) -> F
eqt₂(excl, ok) -> F
eqt₂(excl, pending) -> F
eqt₂(excl, release) -> F
eqt₂(excl, request) -> F
eqt₂(excl, resource) -> F
eqt₂(excl, tag) -> F
eqt₂(excl, true) -> F
eqt₂(excl, undefined) -> F
eqt₂(excl, pid₁(N2)) -> F
eqt₂(excl, eqt₂(false, int₁(N2))) -> F
eqt₂(false, cons₂(H2, T2)) -> F
eqt₂(false, tuple₂(H2, T2)) -> F
eqt₂(false, tuplenil₁(H2)) -> F
eqt₂(lock, nil) -> F
eqt₂(lock, a) -> F
eqt₂(lock, excl) -> F
eqt₂(lock, false) -> F
eqt₂(lock, lock) -> T
eqt₂(lock, locker) -> F
eqt₂(lock, mcrlrecord) -> F
eqt₂(lock, ok) -> F
eqt₂(lock, pending) -> F
eqt₂(lock, release) -> F
eqt₂(lock, request) -> F
eqt₂(lock, resource) -> F
eqt₂(lock, tag) -> F
eqt₂(lock, true) -> F
eqt₂(lock, undefined) -> F
eqt₂(lock, pid₁(N2)) -> F
eqt₂(lock, int₁(N2)) -> F
eqt₂(lock, cons₂(H2, T2)) -> F
eqt₂(lock, tuple₂(H2, T2)) -> F
eqt₂(lock, tuplenil₁(H2)) -> F
eqt₂(locker, nil) -> F
eqt₂(locker, a) -> F
eqt₂(locker, excl) -> F
eqt₂(locker, false) -> F
eqt₂(locker, lock) -> F
eqt₂(locker, locker) -> T
eqt₂(locker, mcrlrecord) -> F
eqt₂(locker, ok) -> F
eqt₂(locker, pending) -> F
eqt₂(locker, release) -> F
eqt₂(locker, request) -> F
eqt₂(locker, resource) -> F
eqt₂(locker, tag) -> F
eqt₂(locker, true) -> F
eqt₂(locker, undefined) -> F
eqt₂(locker, pid₁(N2)) -> F
eqt₂(locker, int₁(N2)) -> F
eqt₂(locker, cons₂(H2, T2)) -> F
eqt₂(locker, tuple₂(H2, T2)) -> F
eqt₂(locker, tuplenil₁(H2)) -> F
eqt₂(mcrlrecord, nil) -> F
eqt₂(mcrlrecord, a) -> F
eqt₂(mcrlrecord, excl) -> F
eqt₂(mcrlrecord, false) -> F
eqt₂(mcrlrecord, lock) -> F
eqt₂(mcrlrecord, locker) -> F
eqt₂(mcrlrecord, mcrlrecord) -> T
eqt₂(mcrlrecord, ok) -> F
eqt₂(mcrlrecord, pending) -> F
eqt₂(mcrlrecord, release) -> F
eqt₂(mcrlrecord, request) -> F
eqt₂(mcrlrecord, resource) -> F
eqt₂(ok, resource) -> F
eqt₂(ok, tag) -> F
eqt₂(ok, true) -> F
eqt₂(ok, undefined) -> F
eqt₂(ok, pid₁(N2)) -> F
eqt₂(ok, int₁(N2)) -> F
eqt₂(ok, cons₂(H2, T2)) -> F
eqt₂(ok, tuple₂(H2, T2)) -> F
eqt₂(ok, tuplenil₁(H2)) -> F
eqt₂(pending, nil) -> F
eqt₂(pending, a) -> F
eqt₂(pending, excl) -> F
eqt₂(pending, false) -> F
eqt₂(pending, lock) -> F
eqt₂(pending, locker) -> F
eqt₂(pending, mcrlrecord) -> F
eqt₂(pending, ok) -> F
eqt₂(pending, pending) -> T
eqt₂(pending, release) -> F
eqt₂(pending, request) -> F
eqt₂(pending, resource) -> F
eqt₂(pending, tag) -> F
eqt₂(pending, true) -> F
eqt₂(pending, undefined) -> F
eqt₂(pending, pid₁(N2)) -> F
eqt₂(pending, int₁(N2)) -> F
eqt₂(pending, cons₂(H2, T2)) -> F
eqt₂(pending, tuple₂(H2, T2)) -> F
eqt₂(pending, tuplenil₁(H2)) -> F
eqt₂(release, nil) -> F
eqt₂(release, a) -> F
eqt₂(release, excl) -> F
eqt₂(release, false) -> F
eqt₂(release, lock) -> F
eqt₂(release, locker) -> F
eqt₂(release, mcrlrecord) -> F
eqt₂(release, ok) -> F
eqt₂(request, mcrlrecord) -> F
eqt₂(request, ok) -> F
eqt₂(request, pending) -> F
eqt₂(request, release) -> F
eqt₂(request, request) -> T
eqt₂(request, resource) -> F
eqt₂(request, tag) -> F
eqt₂(request, true) -> F
eqt₂(request, undefined) -> F
eqt₂(request, pid₁(N2)) -> F
eqt₂(request, int₁(N2)) -> F
eqt₂(request, cons₂(H2, T2)) -> F
eqt₂(request, tuple₂(H2, T2)) -> F
eqt₂(request, tuplenil₁(H2)) -> F
eqt₂(resource, nil) -> F
eqt₂(resource, a) -> F
eqt₂(resource, excl) -> F
eqt₂(resource, false) -> F
eqt₂(resource, lock) -> F
eqt₂(resource, locker) -> F
eqt₂(resource, mcrlrecord) -> F
eqt₂(resource, ok) -> F
eqt₂(resource, pending) -> F
eqt₂(resource, release) -> F
eqt₂(resource, request) -> F
eqt₂(resource, resource) -> T
eqt₂(resource, tag) -> F
eqt₂(resource, true) -> F
eqt₂(resource, undefined) -> F
eqt₂(resource, pid₁(N2)) -> F
eqt₂(resource, int₁(N2)) -> F
eqt₂(resource, cons₂(H2, T2)) -> F
eqt₂(resource, tuple₂(H2, T2)) -> F
eqt₂(resource, tuplenil₁(H2)) -> F
eqt₂(tag, nil) -> F
eqt₂(tag, a) -> F
eqt₂(tag, excl) -> F
eqt₂(tag, false) -> F
eqt₂(tag, lock) -> F
eqt₂(tag, locker) -> F
eqt₂(tag, mcrlrecord) -> F
eqt₂(tag, ok) -> F
eqt₂(tag, pending) -> F
eqt₂(tag, release) -> F
eqt₂(tag, request) -> F
eqt₂(tag, resource) -> F
eqt₂(tag, tag) -> T
eqt₂(tag, true) -> F
eqt₂(tag, undefined) -> F
eqt₂(tag, pid₁(N2)) -> F
eqt₂(tag, int₁(N2)) -> F
eqt₂(tag, cons₂(H2, T2)) -> F
eqt₂(tag, tuple₂(H2, T2)) -> F
eqt₂(tag, tuplenil₁(H2)) -> F
eqt₂(true, nil) -> F
eqt₂(true, a) -> F
eqt₂(true, excl) -> F
eqt₂(true, false) -> F
eqt₂(true, lock) -> F
eqt₂(true, locker) -> F
eqt₂(true, mcrlrecord) -> F
eqt₂(true, ok) -> F
eqt₂(true, pending) -> F
eqt₂(true, release) -> F
eqt₂(true, request) -> F
eqt₂(true, resource) -> F
eqt₂(true, tag) -> F
eqt₂(true, true) -> T
eqt₂(true, undefined) -> F
eqt₂(true, pid₁(N2)) -> F
eqt₂(true, int₁(N2)) -> F
eqt₂(true, cons₂(H2, T2)) -> F
eqt₂(true, tuple₂(H2, T2)) -> F
eqt₂(true, tuplenil₁(H2)) -> F
eqt₂(undefined, nil) -> F
eqt₂(undefined, a) -> F
eqt₂(undefined, tuplenil₁(H2)) -> F
eqt₂(pid₁(N1), nil) -> F
eqt₂(pid₁(N1), a) -> F
eqt₂(pid₁(N1), excl) -> F
eqt₂(pid₁(N1), false) -> F
eqt₂(pid₁(N1), lock) -> F
eqt₂(pid₁(N1), locker) -> F
eqt₂(pid₁(N1), mcrlrecord) -> F
eqt₂(pid₁(N1), ok) -> F
eqt₂(pid₁(N1), pending) -> F
eqt₂(pid₁(N1), release) -> F
eqt₂(pid₁(N1), request) -> F
eqt₂(pid₁(N1), resource) -> F
eqt₂(pid₁(N1), tag) -> F
eqt₂(pid₁(N1), true) -> F
eqt₂(pid₁(N1), undefined) -> F
eqt₂(pid₁(N1), pid₁(N2)) -> eqt₂(N1, N2)
eqt₂(pid₁(N1), int₁(N2)) -> F
eqt₂(pid₁(N1), cons₂(H2, T2)) -> F
eqt₂(pid₁(N1), tuple₂(H2, T2)) -> F
eqt₂(pid₁(N1), tuplenil₁(H2)) -> F
eqt₂(int₁(N1), nil) -> F
eqt₂(int₁(N1), a) -> F
eqt₂(int₁(N1), excl) -> F
eqt₂(int₁(N1), false) -> F
eqt₂(int₁(N1), lock) -> F
eqt₂(int₁(N1), locker) -> F
eqt₂(int₁(N1), mcrlrecord) -> F
eqt₂(int₁(N1), ok) -> F
eqt₂(int₁(N1), pending) -> F
eqt₂(int₁(N1), release) -> F
eqt₂(int₁(N1), request) -> F
eqt₂(int₁(N1), resource) -> F
eqt₂(int₁(N1), tag) -> F
eqt₂(int₁(N1), true) -> F
eqt₂(int₁(N1), undefined) -> F
eqt₂(cons₂(H1, T1), resource) -> F
eqt₂(cons₂(H1, T1), tag) -> F
eqt₂(cons₂(H1, T1), true) -> F
eqt₂(cons₂(H1, T1), undefined) -> F
eqt₂(cons₂(H1, T1), pid₁(N2)) -> F
eqt₂(cons₂(H1, T1), int₁(N2)) -> F
eqt₂(cons₂(H1, T1), cons₂(H2, T2)) -> and₂(eqt₂(H1, H2), eqt₂(T1, T2))
eqt₂(cons₂(H1, T1), tuple₂(H2, T2)) -> F
eqt₂(cons₂(H1, T1), tuplenil₁(H2)) -> F
eqt₂(tuple₂(H1, T1), nil) -> F
eqt₂(tuple₂(H1, T1), a) -> F
eqt₂(tuple₂(H1, T1), excl) -> F
eqt₂(tuple₂(H1, T1), false) -> F
eqt₂(tuple₂(H1, T1), lock) -> F
eqt₂(tuple₂(H1, T1), locker) -> F
eqt₂(tuple₂(H1, T1), mcrlrecord) -> F
eqt₂(tuple₂(H1, T1), ok) -> F
eqt₂(tuple₂(H1, T1), pending) -> F
eqt₂(tuple₂(H1, T1), release) -> F
eqt₂(tuple₂(H1, T1), request) -> F
eqt₂(tuple₂(H1, T1), resource) -> F
eqt₂(tuple₂(H1, T1), tag) -> F
eqt₂(tuple₂(H1, T1), true) -> F
eqt₂(tuple₂(H1, T1), undefined) -> F
eqt₂(tuple₂(H1, T1), pid₁(N2)) -> F
eqt₂(tuple₂(H1, T1), int₁(N2)) -> F
eqt₂(tuple₂(H1, T1), cons₂(H2, T2)) -> F
eqt₂(tuple₂(H1, T1), tuple₂(H2, T2)) -> and₂(eqt₂(H1, H2), eqt₂(T1, T2))
eqt₂(tuple₂(H1, T1), tuplenil₁(H2)) -> F
eqt₂(tuplenil₁(H1), nil) -> F
eqt₂(tuplenil₁(H1), a) -> F
eqt₂(tuplenil₁(H1), excl) -> F
eqt₂(tuplenil₁(H1), false) -> F
eqt₂(tuplenil₁(H1), lock) -> F
eqt₂(tuplenil₁(H1), locker) -> F
eqt₂(tuplenil₁(H1), mcrlrecord) -> F
eqt₂(tuplenil₁(H1), ok) -> F
eqt₂(tuplenil₁(H1), pending) -> F
eqt₂(tuplenil₁(H1), release) -> F
eqt₂(tuplenil₁(H1), request) -> F
eqt₂(tuplenil₁(H1), resource) -> F
eqt₂(tuplenil₁(H1), tag) -> F
eqt₂(tuplenil₁(H1), true) -> F
eqt₂(tuplenil₁(H1), undefined) -> F
eqt₂(tuplenil₁(H1), pid₁(N2)) -> F
eqt₂(tuplenil₁(H1), int₁(N2)) -> F
eqt₂(tuplenil₁(H1), cons₂(H2, T2)) -> F
eqt₂(tuplenil₁(H1), tuple₂(H2, T2)) -> F
eqt₂(tuplenil₁(H1), tuplenil₁(H2)) -> eqt₂(H1, H2)
element₂(int₁(s₁(0)), tuplenil₁(T1)) -> T1
element₂(int₁(s₁(0)), tuple₂(T1, T2)) -> T1
element₂(int₁(s₁(s₁(N1))), tuple₂(T1, T2)) -> element₂(int₁(s₁(N1)), T2)
record_new₁(lock) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(undefined, tuple₂(nil, tuplenil₁(nil)))))
record_extract₃(tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2))))), lock, resource) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2)))))
record_update₄(tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2))))), lock, pending, NewF) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(NewF)))))
record_updates₃(Record, Name, nil) -> Record
record_updates₃(Record, Name, cons₂(tuple₂(Field, tuplenil₁(NewF)), Fields)) -> record_updates₃(record_update₄(Record, Name, Field, NewF), Name, Fields)
locker2_map_promote_pending₂(nil, Pending) -> nil
locker2_map_promote_pending₂(cons₂(Lock, Locks), Pending) -> cons₂(locker2_promote_pending₂(Lock, Pending), locker2_map_promote_pending₂(Locks, Pending))
locker2_map_claim_lock₃(nil, Resources, Client) -> nil
locker2_map_claim_lock₃(cons₂(Lock, Locks), Resources, Client) -> cons₂(locker2_claim_lock₃(Lock, Resources, Client), locker2_map_claim_lock₃(Locks, Resources, Client))
locker2_map_add_pending₃(nil, Resources, Client) -> nil
locker2_promote_pending₂(Lock, Client) -> case0₃(Client, Lock, record_extract₃(Lock, lock, pending))
case0₃(Client, Lock, cons₂(Client, Pendings)) -> record_updates₃(Lock, lock, cons₂(tuple₂(excl, tuplenil₁(Client)), cons₂(tuple₂(pending, tuplenil₁(Pendings)), nil)))
case0₃(Client, Lock, MCRLFree0) -> Lock
locker2_remove_pending₂(Lock, Client) -> record_updates₃(Lock, lock, cons₂(tuple₂(pending, tuplenil₁(subtract₂(record_extract₃(Lock, lock, pending), cons₂(Client, nil)))), nil))
locker2_add_pending₃(Lock, Resources, Client) -> case1₄(Client, Resources, Lock, member₂(record_extract₃(Lock, lock, resource), Resources))
case1₄(Client, Resources, Lock, true) -> record_updates₃(Lock, lock, cons₂(tuple₂(pending, tuplenil₁(append₂(record_extract₃(Lock, lock, pending), cons₂(Client, nil)))), nil))
case1₄(Client, Resources, Lock, false) -> Lock
locker2_release_lock₂(Lock, Client) -> case2₃(Client, Lock, gen_modtageq₂(Client, record_extract₃(Lock, lock, excl)))
case2₃(Client, Lock, true) -> record_updates₃(Lock, lock, cons₂(tuple₂(excllock, excl), nil))
case4₃(Client, Lock, MCRLFree1) -> false
locker2_obtainables₂(nil, Client) -> true
locker2_obtainables₂(cons₂(Lock, Locks), Client) -> case5₄(Client, Locks, Lock, member₂(Client, record_extract₃(Lock, lock, pending)))
case5₄(Client, Locks, Lock, true) -> andt₂(locker2_obtainable₂(Lock, Client), locker2_obtainables₂(Locks, Client))
case5₄(Client, Locks, Lock, false) -> locker2_obtainables₂(Locks, Client)
locker2_check_available₂(Resource, nil) -> false
locker2_check_available₂(Resource, cons₂(Lock, Locks)) -> case6₄(Locks, Lock, Resource, equal₂(Resource, record_extract₃(Lock, lock, resource)))
case6₄(Locks, Lock, Resource, true) -> andt₂(equal₂(record_extract₃(Lock, lock, excl), nil), equal₂(record_extract₃(Lock, lock, pending), nil))
case6₄(Locks, Lock, Resource, false) -> locker2_check_available₂(Resource, Locks)
locker2_check_availables₂(nil, Locks) -> true
locker2_check_availables₂(cons₂(Resource, Resources), Locks) -> andt₂(locker2_check_available₂(Resource, Locks), locker2_check_availables₂(Resources, Locks))
locker2_adduniq₂(nil, List) -> List
append₂(cons₂(Head, Tail), List) -> cons₂(Head, append₂(Tail, List))
subtract₂(List, nil) -> List
subtract₂(List, cons₂(Head, Tail)) -> subtract₂(delete₂(Head, List), Tail)
delete₂(E, nil) -> nil
delete₂(E, cons₂(Head, Tail)) -> case8₄(Tail, Head, E, equal₂(E, Head))
case8₄(Tail, Head, E, true) -> Tail
case8₄(Tail, Head, E, false) -> cons₂(Head, delete₂(E, Tail))
gen_tag₁(Pid) -> tuple₂(Pid, tuplenil₁(tag))
gen_modtageq₂(Client1, Client2) -> equal₂(Client1, Client2)
member₂(E, nil) -> false
member₂(E, cons₂(Head, Tail)) -> case9₄(Tail, Head, E, equal₂(E, Head))
case9₄(Tail, Head, E, true) -> true
case9₄(Tail, Head, E, false) -> member₂(E, Tail)
eqs₂(empty, empty) -> T
eqs₂(empty, stack₂(E2, S2)) -> F
eqs₂(stack₂(E1, S1), empty) -> F
eqs₂(stack₂(E1, S1), stack₂(E2, S2)) -> and₂(eqt₂(E1, E2), eqs₂(S1, S2))
pushs₂(E1, S1) -> stack₂(E1, S1)
pops₁(stack₂(E1, S1)) -> S1
tops₁(stack₂(E1, S1)) -> E1
istops₂(E1, empty) -> F
istops₂(E1, stack₂(E2, S1)) -> eqt₂(E1, E2)
eqc₂(nocalls, nocalls) -> T
eqc₂(nocalls, calls₃(E2, S2, CS2)) -> F
eqc₂(calls₃(E1, S1, CS1), nocalls) -> F
eqc₂(calls₃(E1, S1, CS1), calls₃(E2, S2, CS2)) -> and₂(eqt₂(E1, E2), and₂(eqs₂(S1, S2), eqc₂(CS1, CS2)))
push₃(E1, E2, nocalls) -> calls₃(E1, stack₂(E2, empty), nocalls)
push₃(E1, E2, calls₃(E3, S1, CS1)) -> push1₆(E1, E2, E3, S1, CS1, eqt₂(E1, E3))
push1₆(E1, E2, E3, S1, CS1, T) -> calls₃(E3, pushs₂(E2, S1), CS1)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

APPEND₂(cons₂(Head, Tail), List) -> APPEND₂(Tail, List)

The TRS R consists of the following rules:

or₂(T, T) -> T
or₂(F, T) -> T
or₂(T, F) -> T
or₂(F, F) -> F
and₂(T, B) -> B
and₂(B, T) -> B
and₂(F, B) -> F
and₂(B, F) -> F
imp₂(T, B) -> B
imp₂(F, B) -> T
not₁(T) -> F
not₁(F) -> T
if₃(T, B1, B2) -> B1
if₃(F, B1, B2) -> B2
eq₂(T, T) -> T
eq₂(F, F) -> T
eq₂(T, F) -> F
eq₂(F, T) -> F
eqt₂(nil, undefined) -> F
eqt₂(nil, pid₁(N2)) -> F
eqt₂(nil, int₁(N2)) -> F
eqt₂(nil, cons₂(H2, T2)) -> F
eqt₂(nil, tuple₂(H2, T2)) -> F
eqt₂(nil, tuplenil₁(H2)) -> F
eqt₂(a, nil) -> F
eqt₂(a, a) -> T
eqt₂(a, excl) -> F
eqt₂(a, false) -> F
eqt₂(a, lock) -> F
eqt₂(a, locker) -> F
eqt₂(a, mcrlrecord) -> F
eqt₂(a, ok) -> F
eqt₂(a, pending) -> F
eqt₂(a, release) -> F
eqt₂(a, request) -> F
eqt₂(a, resource) -> F
eqt₂(a, tag) -> F
eqt₂(a, true) -> F
eqt₂(a, undefined) -> F
eqt₂(a, pid₁(N2)) -> F
eqt₂(a, int₁(N2)) -> F
eqt₂(a, cons₂(H2, T2)) -> F
eqt₂(a, tuple₂(H2, T2)) -> F
eqt₂(a, tuplenil₁(H2)) -> F
eqt₂(excl, nil) -> F
eqt₂(excl, a) -> F
eqt₂(excl, excl) -> T
eqt₂(excl, false) -> F
eqt₂(excl, lock) -> F
eqt₂(excl, locker) -> F
eqt₂(excl, mcrlrecord) -> F
eqt₂(excl, ok) -> F
eqt₂(excl, pending) -> F
eqt₂(excl, release) -> F
eqt₂(excl, request) -> F
eqt₂(excl, resource) -> F
eqt₂(excl, tag) -> F
eqt₂(excl, true) -> F
eqt₂(excl, undefined) -> F
eqt₂(excl, pid₁(N2)) -> F
eqt₂(excl, eqt₂(false, int₁(N2))) -> F
eqt₂(false, cons₂(H2, T2)) -> F
eqt₂(false, tuple₂(H2, T2)) -> F
eqt₂(false, tuplenil₁(H2)) -> F
eqt₂(lock, nil) -> F
eqt₂(lock, a) -> F
eqt₂(lock, excl) -> F
eqt₂(lock, false) -> F
eqt₂(lock, lock) -> T
eqt₂(lock, locker) -> F
eqt₂(lock, mcrlrecord) -> F
eqt₂(lock, ok) -> F
eqt₂(lock, pending) -> F
eqt₂(lock, release) -> F
eqt₂(lock, request) -> F
eqt₂(lock, resource) -> F
eqt₂(lock, tag) -> F
eqt₂(lock, true) -> F
eqt₂(lock, undefined) -> F
eqt₂(lock, pid₁(N2)) -> F
eqt₂(lock, int₁(N2)) -> F
eqt₂(lock, cons₂(H2, T2)) -> F
eqt₂(lock, tuple₂(H2, T2)) -> F
eqt₂(lock, tuplenil₁(H2)) -> F
eqt₂(locker, nil) -> F
eqt₂(locker, a) -> F
eqt₂(locker, excl) -> F
eqt₂(locker, false) -> F
eqt₂(locker, lock) -> F
eqt₂(locker, locker) -> T
eqt₂(locker, mcrlrecord) -> F
eqt₂(locker, ok) -> F
eqt₂(locker, pending) -> F
eqt₂(locker, release) -> F
eqt₂(locker, request) -> F
eqt₂(locker, resource) -> F
eqt₂(locker, tag) -> F
eqt₂(locker, true) -> F
eqt₂(locker, undefined) -> F
eqt₂(locker, pid₁(N2)) -> F
eqt₂(locker, int₁(N2)) -> F
eqt₂(locker, cons₂(H2, T2)) -> F
eqt₂(locker, tuple₂(H2, T2)) -> F
eqt₂(locker, tuplenil₁(H2)) -> F
eqt₂(mcrlrecord, nil) -> F
eqt₂(mcrlrecord, a) -> F
eqt₂(mcrlrecord, excl) -> F
eqt₂(mcrlrecord, false) -> F
eqt₂(mcrlrecord, lock) -> F
eqt₂(mcrlrecord, locker) -> F
eqt₂(mcrlrecord, mcrlrecord) -> T
eqt₂(mcrlrecord, ok) -> F
eqt₂(mcrlrecord, pending) -> F
eqt₂(mcrlrecord, release) -> F
eqt₂(mcrlrecord, request) -> F
eqt₂(mcrlrecord, resource) -> F
eqt₂(ok, resource) -> F
eqt₂(ok, tag) -> F
eqt₂(ok, true) -> F
eqt₂(ok, undefined) -> F
eqt₂(ok, pid₁(N2)) -> F
eqt₂(ok, int₁(N2)) -> F
eqt₂(ok, cons₂(H2, T2)) -> F
eqt₂(ok, tuple₂(H2, T2)) -> F
eqt₂(ok, tuplenil₁(H2)) -> F
eqt₂(pending, nil) -> F
eqt₂(pending, a) -> F
eqt₂(pending, excl) -> F
eqt₂(pending, false) -> F
eqt₂(pending, lock) -> F
eqt₂(pending, locker) -> F
eqt₂(pending, mcrlrecord) -> F
eqt₂(pending, ok) -> F
eqt₂(pending, pending) -> T
eqt₂(pending, release) -> F
eqt₂(pending, request) -> F
eqt₂(pending, resource) -> F
eqt₂(pending, tag) -> F
eqt₂(pending, true) -> F
eqt₂(pending, undefined) -> F
eqt₂(pending, pid₁(N2)) -> F
eqt₂(pending, int₁(N2)) -> F
eqt₂(pending, cons₂(H2, T2)) -> F
eqt₂(pending, tuple₂(H2, T2)) -> F
eqt₂(pending, tuplenil₁(H2)) -> F
eqt₂(release, nil) -> F
eqt₂(release, a) -> F
eqt₂(release, excl) -> F
eqt₂(release, false) -> F
eqt₂(release, lock) -> F
eqt₂(release, locker) -> F
eqt₂(release, mcrlrecord) -> F
eqt₂(release, ok) -> F
eqt₂(request, mcrlrecord) -> F
eqt₂(request, ok) -> F
eqt₂(request, pending) -> F
eqt₂(request, release) -> F
eqt₂(request, request) -> T
eqt₂(request, resource) -> F
eqt₂(request, tag) -> F
eqt₂(request, true) -> F
eqt₂(request, undefined) -> F
eqt₂(request, pid₁(N2)) -> F
eqt₂(request, int₁(N2)) -> F
eqt₂(request, cons₂(H2, T2)) -> F
eqt₂(request, tuple₂(H2, T2)) -> F
eqt₂(request, tuplenil₁(H2)) -> F
eqt₂(resource, nil) -> F
eqt₂(resource, a) -> F
eqt₂(resource, excl) -> F
eqt₂(resource, false) -> F
eqt₂(resource, lock) -> F
eqt₂(resource, locker) -> F
eqt₂(resource, mcrlrecord) -> F
eqt₂(resource, ok) -> F
eqt₂(resource, pending) -> F
eqt₂(resource, release) -> F
eqt₂(resource, request) -> F
eqt₂(resource, resource) -> T
eqt₂(resource, tag) -> F
eqt₂(resource, true) -> F
eqt₂(resource, undefined) -> F
eqt₂(resource, pid₁(N2)) -> F
eqt₂(resource, int₁(N2)) -> F
eqt₂(resource, cons₂(H2, T2)) -> F
eqt₂(resource, tuple₂(H2, T2)) -> F
eqt₂(resource, tuplenil₁(H2)) -> F
eqt₂(tag, nil) -> F
eqt₂(tag, a) -> F
eqt₂(tag, excl) -> F
eqt₂(tag, false) -> F
eqt₂(tag, lock) -> F
eqt₂(tag, locker) -> F
eqt₂(tag, mcrlrecord) -> F
eqt₂(tag, ok) -> F
eqt₂(tag, pending) -> F
eqt₂(tag, release) -> F
eqt₂(tag, request) -> F
eqt₂(tag, resource) -> F
eqt₂(tag, tag) -> T
eqt₂(tag, true) -> F
eqt₂(tag, undefined) -> F
eqt₂(tag, pid₁(N2)) -> F
eqt₂(tag, int₁(N2)) -> F
eqt₂(tag, cons₂(H2, T2)) -> F
eqt₂(tag, tuple₂(H2, T2)) -> F
eqt₂(tag, tuplenil₁(H2)) -> F
eqt₂(true, nil) -> F
eqt₂(true, a) -> F
eqt₂(true, excl) -> F
eqt₂(true, false) -> F
eqt₂(true, lock) -> F
eqt₂(true, locker) -> F
eqt₂(true, mcrlrecord) -> F
eqt₂(true, ok) -> F
eqt₂(true, pending) -> F
eqt₂(true, release) -> F
eqt₂(true, request) -> F
eqt₂(true, resource) -> F
eqt₂(true, tag) -> F
eqt₂(true, true) -> T
eqt₂(true, undefined) -> F
eqt₂(true, pid₁(N2)) -> F
eqt₂(true, int₁(N2)) -> F
eqt₂(true, cons₂(H2, T2)) -> F
eqt₂(true, tuple₂(H2, T2)) -> F
eqt₂(true, tuplenil₁(H2)) -> F
eqt₂(undefined, nil) -> F
eqt₂(undefined, a) -> F
eqt₂(undefined, tuplenil₁(H2)) -> F
eqt₂(pid₁(N1), nil) -> F
eqt₂(pid₁(N1), a) -> F
eqt₂(pid₁(N1), excl) -> F
eqt₂(pid₁(N1), false) -> F
eqt₂(pid₁(N1), lock) -> F
eqt₂(pid₁(N1), locker) -> F
eqt₂(pid₁(N1), mcrlrecord) -> F
eqt₂(pid₁(N1), ok) -> F
eqt₂(pid₁(N1), pending) -> F
eqt₂(pid₁(N1), release) -> F
eqt₂(pid₁(N1), request) -> F
eqt₂(pid₁(N1), resource) -> F
eqt₂(pid₁(N1), tag) -> F
eqt₂(pid₁(N1), true) -> F
eqt₂(pid₁(N1), undefined) -> F
eqt₂(pid₁(N1), pid₁(N2)) -> eqt₂(N1, N2)
eqt₂(pid₁(N1), int₁(N2)) -> F
eqt₂(pid₁(N1), cons₂(H2, T2)) -> F
eqt₂(pid₁(N1), tuple₂(H2, T2)) -> F
eqt₂(pid₁(N1), tuplenil₁(H2)) -> F
eqt₂(int₁(N1), nil) -> F
eqt₂(int₁(N1), a) -> F
eqt₂(int₁(N1), excl) -> F
eqt₂(int₁(N1), false) -> F
eqt₂(int₁(N1), lock) -> F
eqt₂(int₁(N1), locker) -> F
eqt₂(int₁(N1), mcrlrecord) -> F
eqt₂(int₁(N1), ok) -> F
eqt₂(int₁(N1), pending) -> F
eqt₂(int₁(N1), release) -> F
eqt₂(int₁(N1), request) -> F
eqt₂(int₁(N1), resource) -> F
eqt₂(int₁(N1), tag) -> F
eqt₂(int₁(N1), true) -> F
eqt₂(int₁(N1), undefined) -> F
eqt₂(cons₂(H1, T1), resource) -> F
eqt₂(cons₂(H1, T1), tag) -> F
eqt₂(cons₂(H1, T1), true) -> F
eqt₂(cons₂(H1, T1), undefined) -> F
eqt₂(cons₂(H1, T1), pid₁(N2)) -> F
eqt₂(cons₂(H1, T1), int₁(N2)) -> F
eqt₂(cons₂(H1, T1), cons₂(H2, T2)) -> and₂(eqt₂(H1, H2), eqt₂(T1, T2))
eqt₂(cons₂(H1, T1), tuple₂(H2, T2)) -> F
eqt₂(cons₂(H1, T1), tuplenil₁(H2)) -> F
eqt₂(tuple₂(H1, T1), nil) -> F
eqt₂(tuple₂(H1, T1), a) -> F
eqt₂(tuple₂(H1, T1), excl) -> F
eqt₂(tuple₂(H1, T1), false) -> F
eqt₂(tuple₂(H1, T1), lock) -> F
eqt₂(tuple₂(H1, T1), locker) -> F
eqt₂(tuple₂(H1, T1), mcrlrecord) -> F
eqt₂(tuple₂(H1, T1), ok) -> F
eqt₂(tuple₂(H1, T1), pending) -> F
eqt₂(tuple₂(H1, T1), release) -> F
eqt₂(tuple₂(H1, T1), request) -> F
eqt₂(tuple₂(H1, T1), resource) -> F
eqt₂(tuple₂(H1, T1), tag) -> F
eqt₂(tuple₂(H1, T1), true) -> F
eqt₂(tuple₂(H1, T1), undefined) -> F
eqt₂(tuple₂(H1, T1), pid₁(N2)) -> F
eqt₂(tuple₂(H1, T1), int₁(N2)) -> F
eqt₂(tuple₂(H1, T1), cons₂(H2, T2)) -> F
eqt₂(tuple₂(H1, T1), tuple₂(H2, T2)) -> and₂(eqt₂(H1, H2), eqt₂(T1, T2))
eqt₂(tuple₂(H1, T1), tuplenil₁(H2)) -> F
eqt₂(tuplenil₁(H1), nil) -> F
eqt₂(tuplenil₁(H1), a) -> F
eqt₂(tuplenil₁(H1), excl) -> F
eqt₂(tuplenil₁(H1), false) -> F
eqt₂(tuplenil₁(H1), lock) -> F
eqt₂(tuplenil₁(H1), locker) -> F
eqt₂(tuplenil₁(H1), mcrlrecord) -> F
eqt₂(tuplenil₁(H1), ok) -> F
eqt₂(tuplenil₁(H1), pending) -> F
eqt₂(tuplenil₁(H1), release) -> F
eqt₂(tuplenil₁(H1), request) -> F
eqt₂(tuplenil₁(H1), resource) -> F
eqt₂(tuplenil₁(H1), tag) -> F
eqt₂(tuplenil₁(H1), true) -> F
eqt₂(tuplenil₁(H1), undefined) -> F
eqt₂(tuplenil₁(H1), pid₁(N2)) -> F
eqt₂(tuplenil₁(H1), int₁(N2)) -> F
eqt₂(tuplenil₁(H1), cons₂(H2, T2)) -> F
eqt₂(tuplenil₁(H1), tuple₂(H2, T2)) -> F
eqt₂(tuplenil₁(H1), tuplenil₁(H2)) -> eqt₂(H1, H2)
element₂(int₁(s₁(0)), tuplenil₁(T1)) -> T1
element₂(int₁(s₁(0)), tuple₂(T1, T2)) -> T1
element₂(int₁(s₁(s₁(N1))), tuple₂(T1, T2)) -> element₂(int₁(s₁(N1)), T2)
record_new₁(lock) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(undefined, tuple₂(nil, tuplenil₁(nil)))))
record_extract₃(tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2))))), lock, resource) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2)))))
record_update₄(tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2))))), lock, pending, NewF) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(NewF)))))
record_updates₃(Record, Name, nil) -> Record
record_updates₃(Record, Name, cons₂(tuple₂(Field, tuplenil₁(NewF)), Fields)) -> record_updates₃(record_update₄(Record, Name, Field, NewF), Name, Fields)
locker2_map_promote_pending₂(nil, Pending) -> nil
locker2_map_promote_pending₂(cons₂(Lock, Locks), Pending) -> cons₂(locker2_promote_pending₂(Lock, Pending), locker2_map_promote_pending₂(Locks, Pending))
locker2_map_claim_lock₃(nil, Resources, Client) -> nil
locker2_map_claim_lock₃(cons₂(Lock, Locks), Resources, Client) -> cons₂(locker2_claim_lock₃(Lock, Resources, Client), locker2_map_claim_lock₃(Locks, Resources, Client))
locker2_map_add_pending₃(nil, Resources, Client) -> nil
locker2_promote_pending₂(Lock, Client) -> case0₃(Client, Lock, record_extract₃(Lock, lock, pending))
case0₃(Client, Lock, cons₂(Client, Pendings)) -> record_updates₃(Lock, lock, cons₂(tuple₂(excl, tuplenil₁(Client)), cons₂(tuple₂(pending, tuplenil₁(Pendings)), nil)))
case0₃(Client, Lock, MCRLFree0) -> Lock
locker2_remove_pending₂(Lock, Client) -> record_updates₃(Lock, lock, cons₂(tuple₂(pending, tuplenil₁(subtract₂(record_extract₃(Lock, lock, pending), cons₂(Client, nil)))), nil))
locker2_add_pending₃(Lock, Resources, Client) -> case1₄(Client, Resources, Lock, member₂(record_extract₃(Lock, lock, resource), Resources))
case1₄(Client, Resources, Lock, true) -> record_updates₃(Lock, lock, cons₂(tuple₂(pending, tuplenil₁(append₂(record_extract₃(Lock, lock, pending), cons₂(Client, nil)))), nil))
case1₄(Client, Resources, Lock, false) -> Lock
locker2_release_lock₂(Lock, Client) -> case2₃(Client, Lock, gen_modtageq₂(Client, record_extract₃(Lock, lock, excl)))
case2₃(Client, Lock, true) -> record_updates₃(Lock, lock, cons₂(tuple₂(excllock, excl), nil))
case4₃(Client, Lock, MCRLFree1) -> false
locker2_obtainables₂(nil, Client) -> true
locker2_obtainables₂(cons₂(Lock, Locks), Client) -> case5₄(Client, Locks, Lock, member₂(Client, record_extract₃(Lock, lock, pending)))
case5₄(Client, Locks, Lock, true) -> andt₂(locker2_obtainable₂(Lock, Client), locker2_obtainables₂(Locks, Client))
case5₄(Client, Locks, Lock, false) -> locker2_obtainables₂(Locks, Client)
locker2_check_available₂(Resource, nil) -> false
locker2_check_available₂(Resource, cons₂(Lock, Locks)) -> case6₄(Locks, Lock, Resource, equal₂(Resource, record_extract₃(Lock, lock, resource)))
case6₄(Locks, Lock, Resource, true) -> andt₂(equal₂(record_extract₃(Lock, lock, excl), nil), equal₂(record_extract₃(Lock, lock, pending), nil))
case6₄(Locks, Lock, Resource, false) -> locker2_check_available₂(Resource, Locks)
locker2_check_availables₂(nil, Locks) -> true
locker2_check_availables₂(cons₂(Resource, Resources), Locks) -> andt₂(locker2_check_available₂(Resource, Locks), locker2_check_availables₂(Resources, Locks))
locker2_adduniq₂(nil, List) -> List
append₂(cons₂(Head, Tail), List) -> cons₂(Head, append₂(Tail, List))
subtract₂(List, nil) -> List
subtract₂(List, cons₂(Head, Tail)) -> subtract₂(delete₂(Head, List), Tail)
delete₂(E, nil) -> nil
delete₂(E, cons₂(Head, Tail)) -> case8₄(Tail, Head, E, equal₂(E, Head))
case8₄(Tail, Head, E, true) -> Tail
case8₄(Tail, Head, E, false) -> cons₂(Head, delete₂(E, Tail))
gen_tag₁(Pid) -> tuple₂(Pid, tuplenil₁(tag))
gen_modtageq₂(Client1, Client2) -> equal₂(Client1, Client2)
member₂(E, nil) -> false
member₂(E, cons₂(Head, Tail)) -> case9₄(Tail, Head, E, equal₂(E, Head))
case9₄(Tail, Head, E, true) -> true
case9₄(Tail, Head, E, false) -> member₂(E, Tail)
eqs₂(empty, empty) -> T
eqs₂(empty, stack₂(E2, S2)) -> F
eqs₂(stack₂(E1, S1), empty) -> F
eqs₂(stack₂(E1, S1), stack₂(E2, S2)) -> and₂(eqt₂(E1, E2), eqs₂(S1, S2))
pushs₂(E1, S1) -> stack₂(E1, S1)
pops₁(stack₂(E1, S1)) -> S1
tops₁(stack₂(E1, S1)) -> E1
istops₂(E1, empty) -> F
istops₂(E1, stack₂(E2, S1)) -> eqt₂(E1, E2)
eqc₂(nocalls, nocalls) -> T
eqc₂(nocalls, calls₃(E2, S2, CS2)) -> F
eqc₂(calls₃(E1, S1, CS1), nocalls) -> F
eqc₂(calls₃(E1, S1, CS1), calls₃(E2, S2, CS2)) -> and₂(eqt₂(E1, E2), and₂(eqs₂(S1, S2), eqc₂(CS1, CS2)))
push₃(E1, E2, nocalls) -> calls₃(E1, stack₂(E2, empty), nocalls)
push₃(E1, E2, calls₃(E3, S1, CS1)) -> push1₆(E1, E2, E3, S1, CS1, eqt₂(E1, E3))
push1₆(E1, E2, E3, S1, CS1, T) -> calls₃(E3, pushs₂(E2, S1), CS1)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

APPEND₂(cons₂(Head, Tail), List) -> APPEND₂(Tail, List)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial Order [17,21] with Interpretation:

POL( APPEND₂(x₁, x₂) ) = x₁ + x₂

POL( cons₂(x₁, x₂) ) = x₁ + x₂ + 1

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

or₂(T, T) -> T
or₂(F, T) -> T
or₂(T, F) -> T
or₂(F, F) -> F
and₂(T, B) -> B
and₂(B, T) -> B
and₂(F, B) -> F
and₂(B, F) -> F
imp₂(T, B) -> B
imp₂(F, B) -> T
not₁(T) -> F
not₁(F) -> T
if₃(T, B1, B2) -> B1
if₃(F, B1, B2) -> B2
eq₂(T, T) -> T
eq₂(F, F) -> T
eq₂(T, F) -> F
eq₂(F, T) -> F
eqt₂(nil, undefined) -> F
eqt₂(nil, pid₁(N2)) -> F
eqt₂(nil, int₁(N2)) -> F
eqt₂(nil, cons₂(H2, T2)) -> F
eqt₂(nil, tuple₂(H2, T2)) -> F
eqt₂(nil, tuplenil₁(H2)) -> F
eqt₂(a, nil) -> F
eqt₂(a, a) -> T
eqt₂(a, excl) -> F
eqt₂(a, false) -> F
eqt₂(a, lock) -> F
eqt₂(a, locker) -> F
eqt₂(a, mcrlrecord) -> F
eqt₂(a, ok) -> F
eqt₂(a, pending) -> F
eqt₂(a, release) -> F
eqt₂(a, request) -> F
eqt₂(a, resource) -> F
eqt₂(a, tag) -> F
eqt₂(a, true) -> F
eqt₂(a, undefined) -> F
eqt₂(a, pid₁(N2)) -> F
eqt₂(a, int₁(N2)) -> F
eqt₂(a, cons₂(H2, T2)) -> F
eqt₂(a, tuple₂(H2, T2)) -> F
eqt₂(a, tuplenil₁(H2)) -> F
eqt₂(excl, nil) -> F
eqt₂(excl, a) -> F
eqt₂(excl, excl) -> T
eqt₂(excl, false) -> F
eqt₂(excl, lock) -> F
eqt₂(excl, locker) -> F
eqt₂(excl, mcrlrecord) -> F
eqt₂(excl, ok) -> F
eqt₂(excl, pending) -> F
eqt₂(excl, release) -> F
eqt₂(excl, request) -> F
eqt₂(excl, resource) -> F
eqt₂(excl, tag) -> F
eqt₂(excl, true) -> F
eqt₂(excl, undefined) -> F
eqt₂(excl, pid₁(N2)) -> F
eqt₂(excl, eqt₂(false, int₁(N2))) -> F
eqt₂(false, cons₂(H2, T2)) -> F
eqt₂(false, tuple₂(H2, T2)) -> F
eqt₂(false, tuplenil₁(H2)) -> F
eqt₂(lock, nil) -> F
eqt₂(lock, a) -> F
eqt₂(lock, excl) -> F
eqt₂(lock, false) -> F
eqt₂(lock, lock) -> T
eqt₂(lock, locker) -> F
eqt₂(lock, mcrlrecord) -> F
eqt₂(lock, ok) -> F
eqt₂(lock, pending) -> F
eqt₂(lock, release) -> F
eqt₂(lock, request) -> F
eqt₂(lock, resource) -> F
eqt₂(lock, tag) -> F
eqt₂(lock, true) -> F
eqt₂(lock, undefined) -> F
eqt₂(lock, pid₁(N2)) -> F
eqt₂(lock, int₁(N2)) -> F
eqt₂(lock, cons₂(H2, T2)) -> F
eqt₂(lock, tuple₂(H2, T2)) -> F
eqt₂(lock, tuplenil₁(H2)) -> F
eqt₂(locker, nil) -> F
eqt₂(locker, a) -> F
eqt₂(locker, excl) -> F
eqt₂(locker, false) -> F
eqt₂(locker, lock) -> F
eqt₂(locker, locker) -> T
eqt₂(locker, mcrlrecord) -> F
eqt₂(locker, ok) -> F
eqt₂(locker, pending) -> F
eqt₂(locker, release) -> F
eqt₂(locker, request) -> F
eqt₂(locker, resource) -> F
eqt₂(locker, tag) -> F
eqt₂(locker, true) -> F
eqt₂(locker, undefined) -> F
eqt₂(locker, pid₁(N2)) -> F
eqt₂(locker, int₁(N2)) -> F
eqt₂(locker, cons₂(H2, T2)) -> F
eqt₂(locker, tuple₂(H2, T2)) -> F
eqt₂(locker, tuplenil₁(H2)) -> F
eqt₂(mcrlrecord, nil) -> F
eqt₂(mcrlrecord, a) -> F
eqt₂(mcrlrecord, excl) -> F
eqt₂(mcrlrecord, false) -> F
eqt₂(mcrlrecord, lock) -> F
eqt₂(mcrlrecord, locker) -> F
eqt₂(mcrlrecord, mcrlrecord) -> T
eqt₂(mcrlrecord, ok) -> F
eqt₂(mcrlrecord, pending) -> F
eqt₂(mcrlrecord, release) -> F
eqt₂(mcrlrecord, request) -> F
eqt₂(mcrlrecord, resource) -> F
eqt₂(ok, resource) -> F
eqt₂(ok, tag) -> F
eqt₂(ok, true) -> F
eqt₂(ok, undefined) -> F
eqt₂(ok, pid₁(N2)) -> F
eqt₂(ok, int₁(N2)) -> F
eqt₂(ok, cons₂(H2, T2)) -> F
eqt₂(ok, tuple₂(H2, T2)) -> F
eqt₂(ok, tuplenil₁(H2)) -> F
eqt₂(pending, nil) -> F
eqt₂(pending, a) -> F
eqt₂(pending, excl) -> F
eqt₂(pending, false) -> F
eqt₂(pending, lock) -> F
eqt₂(pending, locker) -> F
eqt₂(pending, mcrlrecord) -> F
eqt₂(pending, ok) -> F
eqt₂(pending, pending) -> T
eqt₂(pending, release) -> F
eqt₂(pending, request) -> F
eqt₂(pending, resource) -> F
eqt₂(pending, tag) -> F
eqt₂(pending, true) -> F
eqt₂(pending, undefined) -> F
eqt₂(pending, pid₁(N2)) -> F
eqt₂(pending, int₁(N2)) -> F
eqt₂(pending, cons₂(H2, T2)) -> F
eqt₂(pending, tuple₂(H2, T2)) -> F
eqt₂(pending, tuplenil₁(H2)) -> F
eqt₂(release, nil) -> F
eqt₂(release, a) -> F
eqt₂(release, excl) -> F
eqt₂(release, false) -> F
eqt₂(release, lock) -> F
eqt₂(release, locker) -> F
eqt₂(release, mcrlrecord) -> F
eqt₂(release, ok) -> F
eqt₂(request, mcrlrecord) -> F
eqt₂(request, ok) -> F
eqt₂(request, pending) -> F
eqt₂(request, release) -> F
eqt₂(request, request) -> T
eqt₂(request, resource) -> F
eqt₂(request, tag) -> F
eqt₂(request, true) -> F
eqt₂(request, undefined) -> F
eqt₂(request, pid₁(N2)) -> F
eqt₂(request, int₁(N2)) -> F
eqt₂(request, cons₂(H2, T2)) -> F
eqt₂(request, tuple₂(H2, T2)) -> F
eqt₂(request, tuplenil₁(H2)) -> F
eqt₂(resource, nil) -> F
eqt₂(resource, a) -> F
eqt₂(resource, excl) -> F
eqt₂(resource, false) -> F
eqt₂(resource, lock) -> F
eqt₂(resource, locker) -> F
eqt₂(resource, mcrlrecord) -> F
eqt₂(resource, ok) -> F
eqt₂(resource, pending) -> F
eqt₂(resource, release) -> F
eqt₂(resource, request) -> F
eqt₂(resource, resource) -> T
eqt₂(resource, tag) -> F
eqt₂(resource, true) -> F
eqt₂(resource, undefined) -> F
eqt₂(resource, pid₁(N2)) -> F
eqt₂(resource, int₁(N2)) -> F
eqt₂(resource, cons₂(H2, T2)) -> F
eqt₂(resource, tuple₂(H2, T2)) -> F
eqt₂(resource, tuplenil₁(H2)) -> F
eqt₂(tag, nil) -> F
eqt₂(tag, a) -> F
eqt₂(tag, excl) -> F
eqt₂(tag, false) -> F
eqt₂(tag, lock) -> F
eqt₂(tag, locker) -> F
eqt₂(tag, mcrlrecord) -> F
eqt₂(tag, ok) -> F
eqt₂(tag, pending) -> F
eqt₂(tag, release) -> F
eqt₂(tag, request) -> F
eqt₂(tag, resource) -> F
eqt₂(tag, tag) -> T
eqt₂(tag, true) -> F
eqt₂(tag, undefined) -> F
eqt₂(tag, pid₁(N2)) -> F
eqt₂(tag, int₁(N2)) -> F
eqt₂(tag, cons₂(H2, T2)) -> F
eqt₂(tag, tuple₂(H2, T2)) -> F
eqt₂(tag, tuplenil₁(H2)) -> F
eqt₂(true, nil) -> F
eqt₂(true, a) -> F
eqt₂(true, excl) -> F
eqt₂(true, false) -> F
eqt₂(true, lock) -> F
eqt₂(true, locker) -> F
eqt₂(true, mcrlrecord) -> F
eqt₂(true, ok) -> F
eqt₂(true, pending) -> F
eqt₂(true, release) -> F
eqt₂(true, request) -> F
eqt₂(true, resource) -> F
eqt₂(true, tag) -> F
eqt₂(true, true) -> T
eqt₂(true, undefined) -> F
eqt₂(true, pid₁(N2)) -> F
eqt₂(true, int₁(N2)) -> F
eqt₂(true, cons₂(H2, T2)) -> F
eqt₂(true, tuple₂(H2, T2)) -> F
eqt₂(true, tuplenil₁(H2)) -> F
eqt₂(undefined, nil) -> F
eqt₂(undefined, a) -> F
eqt₂(undefined, tuplenil₁(H2)) -> F
eqt₂(pid₁(N1), nil) -> F
eqt₂(pid₁(N1), a) -> F
eqt₂(pid₁(N1), excl) -> F
eqt₂(pid₁(N1), false) -> F
eqt₂(pid₁(N1), lock) -> F
eqt₂(pid₁(N1), locker) -> F
eqt₂(pid₁(N1), mcrlrecord) -> F
eqt₂(pid₁(N1), ok) -> F
eqt₂(pid₁(N1), pending) -> F
eqt₂(pid₁(N1), release) -> F
eqt₂(pid₁(N1), request) -> F
eqt₂(pid₁(N1), resource) -> F
eqt₂(pid₁(N1), tag) -> F
eqt₂(pid₁(N1), true) -> F
eqt₂(pid₁(N1), undefined) -> F
eqt₂(pid₁(N1), pid₁(N2)) -> eqt₂(N1, N2)
eqt₂(pid₁(N1), int₁(N2)) -> F
eqt₂(pid₁(N1), cons₂(H2, T2)) -> F
eqt₂(pid₁(N1), tuple₂(H2, T2)) -> F
eqt₂(pid₁(N1), tuplenil₁(H2)) -> F
eqt₂(int₁(N1), nil) -> F
eqt₂(int₁(N1), a) -> F
eqt₂(int₁(N1), excl) -> F
eqt₂(int₁(N1), false) -> F
eqt₂(int₁(N1), lock) -> F
eqt₂(int₁(N1), locker) -> F
eqt₂(int₁(N1), mcrlrecord) -> F
eqt₂(int₁(N1), ok) -> F
eqt₂(int₁(N1), pending) -> F
eqt₂(int₁(N1), release) -> F
eqt₂(int₁(N1), request) -> F
eqt₂(int₁(N1), resource) -> F
eqt₂(int₁(N1), tag) -> F
eqt₂(int₁(N1), true) -> F
eqt₂(int₁(N1), undefined) -> F
eqt₂(cons₂(H1, T1), resource) -> F
eqt₂(cons₂(H1, T1), tag) -> F
eqt₂(cons₂(H1, T1), true) -> F
eqt₂(cons₂(H1, T1), undefined) -> F
eqt₂(cons₂(H1, T1), pid₁(N2)) -> F
eqt₂(cons₂(H1, T1), int₁(N2)) -> F
eqt₂(cons₂(H1, T1), cons₂(H2, T2)) -> and₂(eqt₂(H1, H2), eqt₂(T1, T2))
eqt₂(cons₂(H1, T1), tuple₂(H2, T2)) -> F
eqt₂(cons₂(H1, T1), tuplenil₁(H2)) -> F
eqt₂(tuple₂(H1, T1), nil) -> F
eqt₂(tuple₂(H1, T1), a) -> F
eqt₂(tuple₂(H1, T1), excl) -> F
eqt₂(tuple₂(H1, T1), false) -> F
eqt₂(tuple₂(H1, T1), lock) -> F
eqt₂(tuple₂(H1, T1), locker) -> F
eqt₂(tuple₂(H1, T1), mcrlrecord) -> F
eqt₂(tuple₂(H1, T1), ok) -> F
eqt₂(tuple₂(H1, T1), pending) -> F
eqt₂(tuple₂(H1, T1), release) -> F
eqt₂(tuple₂(H1, T1), request) -> F
eqt₂(tuple₂(H1, T1), resource) -> F
eqt₂(tuple₂(H1, T1), tag) -> F
eqt₂(tuple₂(H1, T1), true) -> F
eqt₂(tuple₂(H1, T1), undefined) -> F
eqt₂(tuple₂(H1, T1), pid₁(N2)) -> F
eqt₂(tuple₂(H1, T1), int₁(N2)) -> F
eqt₂(tuple₂(H1, T1), cons₂(H2, T2)) -> F
eqt₂(tuple₂(H1, T1), tuple₂(H2, T2)) -> and₂(eqt₂(H1, H2), eqt₂(T1, T2))
eqt₂(tuple₂(H1, T1), tuplenil₁(H2)) -> F
eqt₂(tuplenil₁(H1), nil) -> F
eqt₂(tuplenil₁(H1), a) -> F
eqt₂(tuplenil₁(H1), excl) -> F
eqt₂(tuplenil₁(H1), false) -> F
eqt₂(tuplenil₁(H1), lock) -> F
eqt₂(tuplenil₁(H1), locker) -> F
eqt₂(tuplenil₁(H1), mcrlrecord) -> F
eqt₂(tuplenil₁(H1), ok) -> F
eqt₂(tuplenil₁(H1), pending) -> F
eqt₂(tuplenil₁(H1), release) -> F
eqt₂(tuplenil₁(H1), request) -> F
eqt₂(tuplenil₁(H1), resource) -> F
eqt₂(tuplenil₁(H1), tag) -> F
eqt₂(tuplenil₁(H1), true) -> F
eqt₂(tuplenil₁(H1), undefined) -> F
eqt₂(tuplenil₁(H1), pid₁(N2)) -> F
eqt₂(tuplenil₁(H1), int₁(N2)) -> F
eqt₂(tuplenil₁(H1), cons₂(H2, T2)) -> F
eqt₂(tuplenil₁(H1), tuple₂(H2, T2)) -> F
eqt₂(tuplenil₁(H1), tuplenil₁(H2)) -> eqt₂(H1, H2)
element₂(int₁(s₁(0)), tuplenil₁(T1)) -> T1
element₂(int₁(s₁(0)), tuple₂(T1, T2)) -> T1
element₂(int₁(s₁(s₁(N1))), tuple₂(T1, T2)) -> element₂(int₁(s₁(N1)), T2)
record_new₁(lock) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(undefined, tuple₂(nil, tuplenil₁(nil)))))
record_extract₃(tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2))))), lock, resource) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2)))))
record_update₄(tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2))))), lock, pending, NewF) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(NewF)))))
record_updates₃(Record, Name, nil) -> Record
record_updates₃(Record, Name, cons₂(tuple₂(Field, tuplenil₁(NewF)), Fields)) -> record_updates₃(record_update₄(Record, Name, Field, NewF), Name, Fields)
locker2_map_promote_pending₂(nil, Pending) -> nil
locker2_map_promote_pending₂(cons₂(Lock, Locks), Pending) -> cons₂(locker2_promote_pending₂(Lock, Pending), locker2_map_promote_pending₂(Locks, Pending))
locker2_map_claim_lock₃(nil, Resources, Client) -> nil
locker2_map_claim_lock₃(cons₂(Lock, Locks), Resources, Client) -> cons₂(locker2_claim_lock₃(Lock, Resources, Client), locker2_map_claim_lock₃(Locks, Resources, Client))
locker2_map_add_pending₃(nil, Resources, Client) -> nil
locker2_promote_pending₂(Lock, Client) -> case0₃(Client, Lock, record_extract₃(Lock, lock, pending))
case0₃(Client, Lock, cons₂(Client, Pendings)) -> record_updates₃(Lock, lock, cons₂(tuple₂(excl, tuplenil₁(Client)), cons₂(tuple₂(pending, tuplenil₁(Pendings)), nil)))
case0₃(Client, Lock, MCRLFree0) -> Lock
locker2_remove_pending₂(Lock, Client) -> record_updates₃(Lock, lock, cons₂(tuple₂(pending, tuplenil₁(subtract₂(record_extract₃(Lock, lock, pending), cons₂(Client, nil)))), nil))
locker2_add_pending₃(Lock, Resources, Client) -> case1₄(Client, Resources, Lock, member₂(record_extract₃(Lock, lock, resource), Resources))
case1₄(Client, Resources, Lock, true) -> record_updates₃(Lock, lock, cons₂(tuple₂(pending, tuplenil₁(append₂(record_extract₃(Lock, lock, pending), cons₂(Client, nil)))), nil))
case1₄(Client, Resources, Lock, false) -> Lock
locker2_release_lock₂(Lock, Client) -> case2₃(Client, Lock, gen_modtageq₂(Client, record_extract₃(Lock, lock, excl)))
case2₃(Client, Lock, true) -> record_updates₃(Lock, lock, cons₂(tuple₂(excllock, excl), nil))
case4₃(Client, Lock, MCRLFree1) -> false
locker2_obtainables₂(nil, Client) -> true
locker2_obtainables₂(cons₂(Lock, Locks), Client) -> case5₄(Client, Locks, Lock, member₂(Client, record_extract₃(Lock, lock, pending)))
case5₄(Client, Locks, Lock, true) -> andt₂(locker2_obtainable₂(Lock, Client), locker2_obtainables₂(Locks, Client))
case5₄(Client, Locks, Lock, false) -> locker2_obtainables₂(Locks, Client)
locker2_check_available₂(Resource, nil) -> false
locker2_check_available₂(Resource, cons₂(Lock, Locks)) -> case6₄(Locks, Lock, Resource, equal₂(Resource, record_extract₃(Lock, lock, resource)))
case6₄(Locks, Lock, Resource, true) -> andt₂(equal₂(record_extract₃(Lock, lock, excl), nil), equal₂(record_extract₃(Lock, lock, pending), nil))
case6₄(Locks, Lock, Resource, false) -> locker2_check_available₂(Resource, Locks)
locker2_check_availables₂(nil, Locks) -> true
locker2_check_availables₂(cons₂(Resource, Resources), Locks) -> andt₂(locker2_check_available₂(Resource, Locks), locker2_check_availables₂(Resources, Locks))
locker2_adduniq₂(nil, List) -> List
append₂(cons₂(Head, Tail), List) -> cons₂(Head, append₂(Tail, List))
subtract₂(List, nil) -> List
subtract₂(List, cons₂(Head, Tail)) -> subtract₂(delete₂(Head, List), Tail)
delete₂(E, nil) -> nil
delete₂(E, cons₂(Head, Tail)) -> case8₄(Tail, Head, E, equal₂(E, Head))
case8₄(Tail, Head, E, true) -> Tail
case8₄(Tail, Head, E, false) -> cons₂(Head, delete₂(E, Tail))
gen_tag₁(Pid) -> tuple₂(Pid, tuplenil₁(tag))
gen_modtageq₂(Client1, Client2) -> equal₂(Client1, Client2)
member₂(E, nil) -> false
member₂(E, cons₂(Head, Tail)) -> case9₄(Tail, Head, E, equal₂(E, Head))
case9₄(Tail, Head, E, true) -> true
case9₄(Tail, Head, E, false) -> member₂(E, Tail)
eqs₂(empty, empty) -> T
eqs₂(empty, stack₂(E2, S2)) -> F
eqs₂(stack₂(E1, S1), empty) -> F
eqs₂(stack₂(E1, S1), stack₂(E2, S2)) -> and₂(eqt₂(E1, E2), eqs₂(S1, S2))
pushs₂(E1, S1) -> stack₂(E1, S1)
pops₁(stack₂(E1, S1)) -> S1
tops₁(stack₂(E1, S1)) -> E1
istops₂(E1, empty) -> F
istops₂(E1, stack₂(E2, S1)) -> eqt₂(E1, E2)
eqc₂(nocalls, nocalls) -> T
eqc₂(nocalls, calls₃(E2, S2, CS2)) -> F
eqc₂(calls₃(E1, S1, CS1), nocalls) -> F
eqc₂(calls₃(E1, S1, CS1), calls₃(E2, S2, CS2)) -> and₂(eqt₂(E1, E2), and₂(eqs₂(S1, S2), eqc₂(CS1, CS2)))
push₃(E1, E2, nocalls) -> calls₃(E1, stack₂(E2, empty), nocalls)
push₃(E1, E2, calls₃(E3, S1, CS1)) -> push1₆(E1, E2, E3, S1, CS1, eqt₂(E1, E3))
push1₆(E1, E2, E3, S1, CS1, T) -> calls₃(E3, pushs₂(E2, S1), CS1)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

LOCKER2_CHECK_AVAILABLES₂(cons₂(Resource, Resources), Locks) -> LOCKER2_CHECK_AVAILABLES₂(Resources, Locks)

The TRS R consists of the following rules:

or₂(T, T) -> T
or₂(F, T) -> T
or₂(T, F) -> T
or₂(F, F) -> F
and₂(T, B) -> B
and₂(B, T) -> B
and₂(F, B) -> F
and₂(B, F) -> F
imp₂(T, B) -> B
imp₂(F, B) -> T
not₁(T) -> F
not₁(F) -> T
if₃(T, B1, B2) -> B1
if₃(F, B1, B2) -> B2
eq₂(T, T) -> T
eq₂(F, F) -> T
eq₂(T, F) -> F
eq₂(F, T) -> F
eqt₂(nil, undefined) -> F
eqt₂(nil, pid₁(N2)) -> F
eqt₂(nil, int₁(N2)) -> F
eqt₂(nil, cons₂(H2, T2)) -> F
eqt₂(nil, tuple₂(H2, T2)) -> F
eqt₂(nil, tuplenil₁(H2)) -> F
eqt₂(a, nil) -> F
eqt₂(a, a) -> T
eqt₂(a, excl) -> F
eqt₂(a, false) -> F
eqt₂(a, lock) -> F
eqt₂(a, locker) -> F
eqt₂(a, mcrlrecord) -> F
eqt₂(a, ok) -> F
eqt₂(a, pending) -> F
eqt₂(a, release) -> F
eqt₂(a, request) -> F
eqt₂(a, resource) -> F
eqt₂(a, tag) -> F
eqt₂(a, true) -> F
eqt₂(a, undefined) -> F
eqt₂(a, pid₁(N2)) -> F
eqt₂(a, int₁(N2)) -> F
eqt₂(a, cons₂(H2, T2)) -> F
eqt₂(a, tuple₂(H2, T2)) -> F
eqt₂(a, tuplenil₁(H2)) -> F
eqt₂(excl, nil) -> F
eqt₂(excl, a) -> F
eqt₂(excl, excl) -> T
eqt₂(excl, false) -> F
eqt₂(excl, lock) -> F
eqt₂(excl, locker) -> F
eqt₂(excl, mcrlrecord) -> F
eqt₂(excl, ok) -> F
eqt₂(excl, pending) -> F
eqt₂(excl, release) -> F
eqt₂(excl, request) -> F
eqt₂(excl, resource) -> F
eqt₂(excl, tag) -> F
eqt₂(excl, true) -> F
eqt₂(excl, undefined) -> F
eqt₂(excl, pid₁(N2)) -> F
eqt₂(excl, eqt₂(false, int₁(N2))) -> F
eqt₂(false, cons₂(H2, T2)) -> F
eqt₂(false, tuple₂(H2, T2)) -> F
eqt₂(false, tuplenil₁(H2)) -> F
eqt₂(lock, nil) -> F
eqt₂(lock, a) -> F
eqt₂(lock, excl) -> F
eqt₂(lock, false) -> F
eqt₂(lock, lock) -> T
eqt₂(lock, locker) -> F
eqt₂(lock, mcrlrecord) -> F
eqt₂(lock, ok) -> F
eqt₂(lock, pending) -> F
eqt₂(lock, release) -> F
eqt₂(lock, request) -> F
eqt₂(lock, resource) -> F
eqt₂(lock, tag) -> F
eqt₂(lock, true) -> F
eqt₂(lock, undefined) -> F
eqt₂(lock, pid₁(N2)) -> F
eqt₂(lock, int₁(N2)) -> F
eqt₂(lock, cons₂(H2, T2)) -> F
eqt₂(lock, tuple₂(H2, T2)) -> F
eqt₂(lock, tuplenil₁(H2)) -> F
eqt₂(locker, nil) -> F
eqt₂(locker, a) -> F
eqt₂(locker, excl) -> F
eqt₂(locker, false) -> F
eqt₂(locker, lock) -> F
eqt₂(locker, locker) -> T
eqt₂(locker, mcrlrecord) -> F
eqt₂(locker, ok) -> F
eqt₂(locker, pending) -> F
eqt₂(locker, release) -> F
eqt₂(locker, request) -> F
eqt₂(locker, resource) -> F
eqt₂(locker, tag) -> F
eqt₂(locker, true) -> F
eqt₂(locker, undefined) -> F
eqt₂(locker, pid₁(N2)) -> F
eqt₂(locker, int₁(N2)) -> F
eqt₂(locker, cons₂(H2, T2)) -> F
eqt₂(locker, tuple₂(H2, T2)) -> F
eqt₂(locker, tuplenil₁(H2)) -> F
eqt₂(mcrlrecord, nil) -> F
eqt₂(mcrlrecord, a) -> F
eqt₂(mcrlrecord, excl) -> F
eqt₂(mcrlrecord, false) -> F
eqt₂(mcrlrecord, lock) -> F
eqt₂(mcrlrecord, locker) -> F
eqt₂(mcrlrecord, mcrlrecord) -> T
eqt₂(mcrlrecord, ok) -> F
eqt₂(mcrlrecord, pending) -> F
eqt₂(mcrlrecord, release) -> F
eqt₂(mcrlrecord, request) -> F
eqt₂(mcrlrecord, resource) -> F
eqt₂(ok, resource) -> F
eqt₂(ok, tag) -> F
eqt₂(ok, true) -> F
eqt₂(ok, undefined) -> F
eqt₂(ok, pid₁(N2)) -> F
eqt₂(ok, int₁(N2)) -> F
eqt₂(ok, cons₂(H2, T2)) -> F
eqt₂(ok, tuple₂(H2, T2)) -> F
eqt₂(ok, tuplenil₁(H2)) -> F
eqt₂(pending, nil) -> F
eqt₂(pending, a) -> F
eqt₂(pending, excl) -> F
eqt₂(pending, false) -> F
eqt₂(pending, lock) -> F
eqt₂(pending, locker) -> F
eqt₂(pending, mcrlrecord) -> F
eqt₂(pending, ok) -> F
eqt₂(pending, pending) -> T
eqt₂(pending, release) -> F
eqt₂(pending, request) -> F
eqt₂(pending, resource) -> F
eqt₂(pending, tag) -> F
eqt₂(pending, true) -> F
eqt₂(pending, undefined) -> F
eqt₂(pending, pid₁(N2)) -> F
eqt₂(pending, int₁(N2)) -> F
eqt₂(pending, cons₂(H2, T2)) -> F
eqt₂(pending, tuple₂(H2, T2)) -> F
eqt₂(pending, tuplenil₁(H2)) -> F
eqt₂(release, nil) -> F
eqt₂(release, a) -> F
eqt₂(release, excl) -> F
eqt₂(release, false) -> F
eqt₂(release, lock) -> F
eqt₂(release, locker) -> F
eqt₂(release, mcrlrecord) -> F
eqt₂(release, ok) -> F
eqt₂(request, mcrlrecord) -> F
eqt₂(request, ok) -> F
eqt₂(request, pending) -> F
eqt₂(request, release) -> F
eqt₂(request, request) -> T
eqt₂(request, resource) -> F
eqt₂(request, tag) -> F
eqt₂(request, true) -> F
eqt₂(request, undefined) -> F
eqt₂(request, pid₁(N2)) -> F
eqt₂(request, int₁(N2)) -> F
eqt₂(request, cons₂(H2, T2)) -> F
eqt₂(request, tuple₂(H2, T2)) -> F
eqt₂(request, tuplenil₁(H2)) -> F
eqt₂(resource, nil) -> F
eqt₂(resource, a) -> F
eqt₂(resource, excl) -> F
eqt₂(resource, false) -> F
eqt₂(resource, lock) -> F
eqt₂(resource, locker) -> F
eqt₂(resource, mcrlrecord) -> F
eqt₂(resource, ok) -> F
eqt₂(resource, pending) -> F
eqt₂(resource, release) -> F
eqt₂(resource, request) -> F
eqt₂(resource, resource) -> T
eqt₂(resource, tag) -> F
eqt₂(resource, true) -> F
eqt₂(resource, undefined) -> F
eqt₂(resource, pid₁(N2)) -> F
eqt₂(resource, int₁(N2)) -> F
eqt₂(resource, cons₂(H2, T2)) -> F
eqt₂(resource, tuple₂(H2, T2)) -> F
eqt₂(resource, tuplenil₁(H2)) -> F
eqt₂(tag, nil) -> F
eqt₂(tag, a) -> F
eqt₂(tag, excl) -> F
eqt₂(tag, false) -> F
eqt₂(tag, lock) -> F
eqt₂(tag, locker) -> F
eqt₂(tag, mcrlrecord) -> F
eqt₂(tag, ok) -> F
eqt₂(tag, pending) -> F
eqt₂(tag, release) -> F
eqt₂(tag, request) -> F
eqt₂(tag, resource) -> F
eqt₂(tag, tag) -> T
eqt₂(tag, true) -> F
eqt₂(tag, undefined) -> F
eqt₂(tag, pid₁(N2)) -> F
eqt₂(tag, int₁(N2)) -> F
eqt₂(tag, cons₂(H2, T2)) -> F
eqt₂(tag, tuple₂(H2, T2)) -> F
eqt₂(tag, tuplenil₁(H2)) -> F
eqt₂(true, nil) -> F
eqt₂(true, a) -> F
eqt₂(true, excl) -> F
eqt₂(true, false) -> F
eqt₂(true, lock) -> F
eqt₂(true, locker) -> F
eqt₂(true, mcrlrecord) -> F
eqt₂(true, ok) -> F
eqt₂(true, pending) -> F
eqt₂(true, release) -> F
eqt₂(true, request) -> F
eqt₂(true, resource) -> F
eqt₂(true, tag) -> F
eqt₂(true, true) -> T
eqt₂(true, undefined) -> F
eqt₂(true, pid₁(N2)) -> F
eqt₂(true, int₁(N2)) -> F
eqt₂(true, cons₂(H2, T2)) -> F
eqt₂(true, tuple₂(H2, T2)) -> F
eqt₂(true, tuplenil₁(H2)) -> F
eqt₂(undefined, nil) -> F
eqt₂(undefined, a) -> F
eqt₂(undefined, tuplenil₁(H2)) -> F
eqt₂(pid₁(N1), nil) -> F
eqt₂(pid₁(N1), a) -> F
eqt₂(pid₁(N1), excl) -> F
eqt₂(pid₁(N1), false) -> F
eqt₂(pid₁(N1), lock) -> F
eqt₂(pid₁(N1), locker) -> F
eqt₂(pid₁(N1), mcrlrecord) -> F
eqt₂(pid₁(N1), ok) -> F
eqt₂(pid₁(N1), pending) -> F
eqt₂(pid₁(N1), release) -> F
eqt₂(pid₁(N1), request) -> F
eqt₂(pid₁(N1), resource) -> F
eqt₂(pid₁(N1), tag) -> F
eqt₂(pid₁(N1), true) -> F
eqt₂(pid₁(N1), undefined) -> F
eqt₂(pid₁(N1), pid₁(N2)) -> eqt₂(N1, N2)
eqt₂(pid₁(N1), int₁(N2)) -> F
eqt₂(pid₁(N1), cons₂(H2, T2)) -> F
eqt₂(pid₁(N1), tuple₂(H2, T2)) -> F
eqt₂(pid₁(N1), tuplenil₁(H2)) -> F
eqt₂(int₁(N1), nil) -> F
eqt₂(int₁(N1), a) -> F
eqt₂(int₁(N1), excl) -> F
eqt₂(int₁(N1), false) -> F
eqt₂(int₁(N1), lock) -> F
eqt₂(int₁(N1), locker) -> F
eqt₂(int₁(N1), mcrlrecord) -> F
eqt₂(int₁(N1), ok) -> F
eqt₂(int₁(N1), pending) -> F
eqt₂(int₁(N1), release) -> F
eqt₂(int₁(N1), request) -> F
eqt₂(int₁(N1), resource) -> F
eqt₂(int₁(N1), tag) -> F
eqt₂(int₁(N1), true) -> F
eqt₂(int₁(N1), undefined) -> F
eqt₂(cons₂(H1, T1), resource) -> F
eqt₂(cons₂(H1, T1), tag) -> F
eqt₂(cons₂(H1, T1), true) -> F
eqt₂(cons₂(H1, T1), undefined) -> F
eqt₂(cons₂(H1, T1), pid₁(N2)) -> F
eqt₂(cons₂(H1, T1), int₁(N2)) -> F
eqt₂(cons₂(H1, T1), cons₂(H2, T2)) -> and₂(eqt₂(H1, H2), eqt₂(T1, T2))
eqt₂(cons₂(H1, T1), tuple₂(H2, T2)) -> F
eqt₂(cons₂(H1, T1), tuplenil₁(H2)) -> F
eqt₂(tuple₂(H1, T1), nil) -> F
eqt₂(tuple₂(H1, T1), a) -> F
eqt₂(tuple₂(H1, T1), excl) -> F
eqt₂(tuple₂(H1, T1), false) -> F
eqt₂(tuple₂(H1, T1), lock) -> F
eqt₂(tuple₂(H1, T1), locker) -> F
eqt₂(tuple₂(H1, T1), mcrlrecord) -> F
eqt₂(tuple₂(H1, T1), ok) -> F
eqt₂(tuple₂(H1, T1), pending) -> F
eqt₂(tuple₂(H1, T1), release) -> F
eqt₂(tuple₂(H1, T1), request) -> F
eqt₂(tuple₂(H1, T1), resource) -> F
eqt₂(tuple₂(H1, T1), tag) -> F
eqt₂(tuple₂(H1, T1), true) -> F
eqt₂(tuple₂(H1, T1), undefined) -> F
eqt₂(tuple₂(H1, T1), pid₁(N2)) -> F
eqt₂(tuple₂(H1, T1), int₁(N2)) -> F
eqt₂(tuple₂(H1, T1), cons₂(H2, T2)) -> F
eqt₂(tuple₂(H1, T1), tuple₂(H2, T2)) -> and₂(eqt₂(H1, H2), eqt₂(T1, T2))
eqt₂(tuple₂(H1, T1), tuplenil₁(H2)) -> F
eqt₂(tuplenil₁(H1), nil) -> F
eqt₂(tuplenil₁(H1), a) -> F
eqt₂(tuplenil₁(H1), excl) -> F
eqt₂(tuplenil₁(H1), false) -> F
eqt₂(tuplenil₁(H1), lock) -> F
eqt₂(tuplenil₁(H1), locker) -> F
eqt₂(tuplenil₁(H1), mcrlrecord) -> F
eqt₂(tuplenil₁(H1), ok) -> F
eqt₂(tuplenil₁(H1), pending) -> F
eqt₂(tuplenil₁(H1), release) -> F
eqt₂(tuplenil₁(H1), request) -> F
eqt₂(tuplenil₁(H1), resource) -> F
eqt₂(tuplenil₁(H1), tag) -> F
eqt₂(tuplenil₁(H1), true) -> F
eqt₂(tuplenil₁(H1), undefined) -> F
eqt₂(tuplenil₁(H1), pid₁(N2)) -> F
eqt₂(tuplenil₁(H1), int₁(N2)) -> F
eqt₂(tuplenil₁(H1), cons₂(H2, T2)) -> F
eqt₂(tuplenil₁(H1), tuple₂(H2, T2)) -> F
eqt₂(tuplenil₁(H1), tuplenil₁(H2)) -> eqt₂(H1, H2)
element₂(int₁(s₁(0)), tuplenil₁(T1)) -> T1
element₂(int₁(s₁(0)), tuple₂(T1, T2)) -> T1
element₂(int₁(s₁(s₁(N1))), tuple₂(T1, T2)) -> element₂(int₁(s₁(N1)), T2)
record_new₁(lock) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(undefined, tuple₂(nil, tuplenil₁(nil)))))
record_extract₃(tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2))))), lock, resource) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2)))))
record_update₄(tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2))))), lock, pending, NewF) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(NewF)))))
record_updates₃(Record, Name, nil) -> Record
record_updates₃(Record, Name, cons₂(tuple₂(Field, tuplenil₁(NewF)), Fields)) -> record_updates₃(record_update₄(Record, Name, Field, NewF), Name, Fields)
locker2_map_promote_pending₂(nil, Pending) -> nil
locker2_map_promote_pending₂(cons₂(Lock, Locks), Pending) -> cons₂(locker2_promote_pending₂(Lock, Pending), locker2_map_promote_pending₂(Locks, Pending))
locker2_map_claim_lock₃(nil, Resources, Client) -> nil
locker2_map_claim_lock₃(cons₂(Lock, Locks), Resources, Client) -> cons₂(locker2_claim_lock₃(Lock, Resources, Client), locker2_map_claim_lock₃(Locks, Resources, Client))
locker2_map_add_pending₃(nil, Resources, Client) -> nil
locker2_promote_pending₂(Lock, Client) -> case0₃(Client, Lock, record_extract₃(Lock, lock, pending))
case0₃(Client, Lock, cons₂(Client, Pendings)) -> record_updates₃(Lock, lock, cons₂(tuple₂(excl, tuplenil₁(Client)), cons₂(tuple₂(pending, tuplenil₁(Pendings)), nil)))
case0₃(Client, Lock, MCRLFree0) -> Lock
locker2_remove_pending₂(Lock, Client) -> record_updates₃(Lock, lock, cons₂(tuple₂(pending, tuplenil₁(subtract₂(record_extract₃(Lock, lock, pending), cons₂(Client, nil)))), nil))
locker2_add_pending₃(Lock, Resources, Client) -> case1₄(Client, Resources, Lock, member₂(record_extract₃(Lock, lock, resource), Resources))
case1₄(Client, Resources, Lock, true) -> record_updates₃(Lock, lock, cons₂(tuple₂(pending, tuplenil₁(append₂(record_extract₃(Lock, lock, pending), cons₂(Client, nil)))), nil))
case1₄(Client, Resources, Lock, false) -> Lock
locker2_release_lock₂(Lock, Client) -> case2₃(Client, Lock, gen_modtageq₂(Client, record_extract₃(Lock, lock, excl)))
case2₃(Client, Lock, true) -> record_updates₃(Lock, lock, cons₂(tuple₂(excllock, excl), nil))
case4₃(Client, Lock, MCRLFree1) -> false
locker2_obtainables₂(nil, Client) -> true
locker2_obtainables₂(cons₂(Lock, Locks), Client) -> case5₄(Client, Locks, Lock, member₂(Client, record_extract₃(Lock, lock, pending)))
case5₄(Client, Locks, Lock, true) -> andt₂(locker2_obtainable₂(Lock, Client), locker2_obtainables₂(Locks, Client))
case5₄(Client, Locks, Lock, false) -> locker2_obtainables₂(Locks, Client)
locker2_check_available₂(Resource, nil) -> false
locker2_check_available₂(Resource, cons₂(Lock, Locks)) -> case6₄(Locks, Lock, Resource, equal₂(Resource, record_extract₃(Lock, lock, resource)))
case6₄(Locks, Lock, Resource, true) -> andt₂(equal₂(record_extract₃(Lock, lock, excl), nil), equal₂(record_extract₃(Lock, lock, pending), nil))
case6₄(Locks, Lock, Resource, false) -> locker2_check_available₂(Resource, Locks)
locker2_check_availables₂(nil, Locks) -> true
locker2_check_availables₂(cons₂(Resource, Resources), Locks) -> andt₂(locker2_check_available₂(Resource, Locks), locker2_check_availables₂(Resources, Locks))
locker2_adduniq₂(nil, List) -> List
append₂(cons₂(Head, Tail), List) -> cons₂(Head, append₂(Tail, List))
subtract₂(List, nil) -> List
subtract₂(List, cons₂(Head, Tail)) -> subtract₂(delete₂(Head, List), Tail)
delete₂(E, nil) -> nil
delete₂(E, cons₂(Head, Tail)) -> case8₄(Tail, Head, E, equal₂(E, Head))
case8₄(Tail, Head, E, true) -> Tail
case8₄(Tail, Head, E, false) -> cons₂(Head, delete₂(E, Tail))
gen_tag₁(Pid) -> tuple₂(Pid, tuplenil₁(tag))
gen_modtageq₂(Client1, Client2) -> equal₂(Client1, Client2)
member₂(E, nil) -> false
member₂(E, cons₂(Head, Tail)) -> case9₄(Tail, Head, E, equal₂(E, Head))
case9₄(Tail, Head, E, true) -> true
case9₄(Tail, Head, E, false) -> member₂(E, Tail)
eqs₂(empty, empty) -> T
eqs₂(empty, stack₂(E2, S2)) -> F
eqs₂(stack₂(E1, S1), empty) -> F
eqs₂(stack₂(E1, S1), stack₂(E2, S2)) -> and₂(eqt₂(E1, E2), eqs₂(S1, S2))
pushs₂(E1, S1) -> stack₂(E1, S1)
pops₁(stack₂(E1, S1)) -> S1
tops₁(stack₂(E1, S1)) -> E1
istops₂(E1, empty) -> F
istops₂(E1, stack₂(E2, S1)) -> eqt₂(E1, E2)
eqc₂(nocalls, nocalls) -> T
eqc₂(nocalls, calls₃(E2, S2, CS2)) -> F
eqc₂(calls₃(E1, S1, CS1), nocalls) -> F
eqc₂(calls₃(E1, S1, CS1), calls₃(E2, S2, CS2)) -> and₂(eqt₂(E1, E2), and₂(eqs₂(S1, S2), eqc₂(CS1, CS2)))
push₃(E1, E2, nocalls) -> calls₃(E1, stack₂(E2, empty), nocalls)
push₃(E1, E2, calls₃(E3, S1, CS1)) -> push1₆(E1, E2, E3, S1, CS1, eqt₂(E1, E3))
push1₆(E1, E2, E3, S1, CS1, T) -> calls₃(E3, pushs₂(E2, S1), CS1)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

LOCKER2_CHECK_AVAILABLES₂(cons₂(Resource, Resources), Locks) -> LOCKER2_CHECK_AVAILABLES₂(Resources, Locks)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial Order [17,21] with Interpretation:

POL( cons₂(x₁, x₂) ) = x₁ + x₂ + 1

POL( LOCKER2_CHECK_AVAILABLES₂(x₁, x₂) ) = x₁ + x₂

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

or₂(T, T) -> T
or₂(F, T) -> T
or₂(T, F) -> T
or₂(F, F) -> F
and₂(T, B) -> B
and₂(B, T) -> B
and₂(F, B) -> F
and₂(B, F) -> F
imp₂(T, B) -> B
imp₂(F, B) -> T
not₁(T) -> F
not₁(F) -> T
if₃(T, B1, B2) -> B1
if₃(F, B1, B2) -> B2
eq₂(T, T) -> T
eq₂(F, F) -> T
eq₂(T, F) -> F
eq₂(F, T) -> F
eqt₂(nil, undefined) -> F
eqt₂(nil, pid₁(N2)) -> F
eqt₂(nil, int₁(N2)) -> F
eqt₂(nil, cons₂(H2, T2)) -> F
eqt₂(nil, tuple₂(H2, T2)) -> F
eqt₂(nil, tuplenil₁(H2)) -> F
eqt₂(a, nil) -> F
eqt₂(a, a) -> T
eqt₂(a, excl) -> F
eqt₂(a, false) -> F
eqt₂(a, lock) -> F
eqt₂(a, locker) -> F
eqt₂(a, mcrlrecord) -> F
eqt₂(a, ok) -> F
eqt₂(a, pending) -> F
eqt₂(a, release) -> F
eqt₂(a, request) -> F
eqt₂(a, resource) -> F
eqt₂(a, tag) -> F
eqt₂(a, true) -> F
eqt₂(a, undefined) -> F
eqt₂(a, pid₁(N2)) -> F
eqt₂(a, int₁(N2)) -> F
eqt₂(a, cons₂(H2, T2)) -> F
eqt₂(a, tuple₂(H2, T2)) -> F
eqt₂(a, tuplenil₁(H2)) -> F
eqt₂(excl, nil) -> F
eqt₂(excl, a) -> F
eqt₂(excl, excl) -> T
eqt₂(excl, false) -> F
eqt₂(excl, lock) -> F
eqt₂(excl, locker) -> F
eqt₂(excl, mcrlrecord) -> F
eqt₂(excl, ok) -> F
eqt₂(excl, pending) -> F
eqt₂(excl, release) -> F
eqt₂(excl, request) -> F
eqt₂(excl, resource) -> F
eqt₂(excl, tag) -> F
eqt₂(excl, true) -> F
eqt₂(excl, undefined) -> F
eqt₂(excl, pid₁(N2)) -> F
eqt₂(excl, eqt₂(false, int₁(N2))) -> F
eqt₂(false, cons₂(H2, T2)) -> F
eqt₂(false, tuple₂(H2, T2)) -> F
eqt₂(false, tuplenil₁(H2)) -> F
eqt₂(lock, nil) -> F
eqt₂(lock, a) -> F
eqt₂(lock, excl) -> F
eqt₂(lock, false) -> F
eqt₂(lock, lock) -> T
eqt₂(lock, locker) -> F
eqt₂(lock, mcrlrecord) -> F
eqt₂(lock, ok) -> F
eqt₂(lock, pending) -> F
eqt₂(lock, release) -> F
eqt₂(lock, request) -> F
eqt₂(lock, resource) -> F
eqt₂(lock, tag) -> F
eqt₂(lock, true) -> F
eqt₂(lock, undefined) -> F
eqt₂(lock, pid₁(N2)) -> F
eqt₂(lock, int₁(N2)) -> F
eqt₂(lock, cons₂(H2, T2)) -> F
eqt₂(lock, tuple₂(H2, T2)) -> F
eqt₂(lock, tuplenil₁(H2)) -> F
eqt₂(locker, nil) -> F
eqt₂(locker, a) -> F
eqt₂(locker, excl) -> F
eqt₂(locker, false) -> F
eqt₂(locker, lock) -> F
eqt₂(locker, locker) -> T
eqt₂(locker, mcrlrecord) -> F
eqt₂(locker, ok) -> F
eqt₂(locker, pending) -> F
eqt₂(locker, release) -> F
eqt₂(locker, request) -> F
eqt₂(locker, resource) -> F
eqt₂(locker, tag) -> F
eqt₂(locker, true) -> F
eqt₂(locker, undefined) -> F
eqt₂(locker, pid₁(N2)) -> F
eqt₂(locker, int₁(N2)) -> F
eqt₂(locker, cons₂(H2, T2)) -> F
eqt₂(locker, tuple₂(H2, T2)) -> F
eqt₂(locker, tuplenil₁(H2)) -> F
eqt₂(mcrlrecord, nil) -> F
eqt₂(mcrlrecord, a) -> F
eqt₂(mcrlrecord, excl) -> F
eqt₂(mcrlrecord, false) -> F
eqt₂(mcrlrecord, lock) -> F
eqt₂(mcrlrecord, locker) -> F
eqt₂(mcrlrecord, mcrlrecord) -> T
eqt₂(mcrlrecord, ok) -> F
eqt₂(mcrlrecord, pending) -> F
eqt₂(mcrlrecord, release) -> F
eqt₂(mcrlrecord, request) -> F
eqt₂(mcrlrecord, resource) -> F
eqt₂(ok, resource) -> F
eqt₂(ok, tag) -> F
eqt₂(ok, true) -> F
eqt₂(ok, undefined) -> F
eqt₂(ok, pid₁(N2)) -> F
eqt₂(ok, int₁(N2)) -> F
eqt₂(ok, cons₂(H2, T2)) -> F
eqt₂(ok, tuple₂(H2, T2)) -> F
eqt₂(ok, tuplenil₁(H2)) -> F
eqt₂(pending, nil) -> F
eqt₂(pending, a) -> F
eqt₂(pending, excl) -> F
eqt₂(pending, false) -> F
eqt₂(pending, lock) -> F
eqt₂(pending, locker) -> F
eqt₂(pending, mcrlrecord) -> F
eqt₂(pending, ok) -> F
eqt₂(pending, pending) -> T
eqt₂(pending, release) -> F
eqt₂(pending, request) -> F
eqt₂(pending, resource) -> F
eqt₂(pending, tag) -> F
eqt₂(pending, true) -> F
eqt₂(pending, undefined) -> F
eqt₂(pending, pid₁(N2)) -> F
eqt₂(pending, int₁(N2)) -> F
eqt₂(pending, cons₂(H2, T2)) -> F
eqt₂(pending, tuple₂(H2, T2)) -> F
eqt₂(pending, tuplenil₁(H2)) -> F
eqt₂(release, nil) -> F
eqt₂(release, a) -> F
eqt₂(release, excl) -> F
eqt₂(release, false) -> F
eqt₂(release, lock) -> F
eqt₂(release, locker) -> F
eqt₂(release, mcrlrecord) -> F
eqt₂(release, ok) -> F
eqt₂(request, mcrlrecord) -> F
eqt₂(request, ok) -> F
eqt₂(request, pending) -> F
eqt₂(request, release) -> F
eqt₂(request, request) -> T
eqt₂(request, resource) -> F
eqt₂(request, tag) -> F
eqt₂(request, true) -> F
eqt₂(request, undefined) -> F
eqt₂(request, pid₁(N2)) -> F
eqt₂(request, int₁(N2)) -> F
eqt₂(request, cons₂(H2, T2)) -> F
eqt₂(request, tuple₂(H2, T2)) -> F
eqt₂(request, tuplenil₁(H2)) -> F
eqt₂(resource, nil) -> F
eqt₂(resource, a) -> F
eqt₂(resource, excl) -> F
eqt₂(resource, false) -> F
eqt₂(resource, lock) -> F
eqt₂(resource, locker) -> F
eqt₂(resource, mcrlrecord) -> F
eqt₂(resource, ok) -> F
eqt₂(resource, pending) -> F
eqt₂(resource, release) -> F
eqt₂(resource, request) -> F
eqt₂(resource, resource) -> T
eqt₂(resource, tag) -> F
eqt₂(resource, true) -> F
eqt₂(resource, undefined) -> F
eqt₂(resource, pid₁(N2)) -> F
eqt₂(resource, int₁(N2)) -> F
eqt₂(resource, cons₂(H2, T2)) -> F
eqt₂(resource, tuple₂(H2, T2)) -> F
eqt₂(resource, tuplenil₁(H2)) -> F
eqt₂(tag, nil) -> F
eqt₂(tag, a) -> F
eqt₂(tag, excl) -> F
eqt₂(tag, false) -> F
eqt₂(tag, lock) -> F
eqt₂(tag, locker) -> F
eqt₂(tag, mcrlrecord) -> F
eqt₂(tag, ok) -> F
eqt₂(tag, pending) -> F
eqt₂(tag, release) -> F
eqt₂(tag, request) -> F
eqt₂(tag, resource) -> F
eqt₂(tag, tag) -> T
eqt₂(tag, true) -> F
eqt₂(tag, undefined) -> F
eqt₂(tag, pid₁(N2)) -> F
eqt₂(tag, int₁(N2)) -> F
eqt₂(tag, cons₂(H2, T2)) -> F
eqt₂(tag, tuple₂(H2, T2)) -> F
eqt₂(tag, tuplenil₁(H2)) -> F
eqt₂(true, nil) -> F
eqt₂(true, a) -> F
eqt₂(true, excl) -> F
eqt₂(true, false) -> F
eqt₂(true, lock) -> F
eqt₂(true, locker) -> F
eqt₂(true, mcrlrecord) -> F
eqt₂(true, ok) -> F
eqt₂(true, pending) -> F
eqt₂(true, release) -> F
eqt₂(true, request) -> F
eqt₂(true, resource) -> F
eqt₂(true, tag) -> F
eqt₂(true, true) -> T
eqt₂(true, undefined) -> F
eqt₂(true, pid₁(N2)) -> F
eqt₂(true, int₁(N2)) -> F
eqt₂(true, cons₂(H2, T2)) -> F
eqt₂(true, tuple₂(H2, T2)) -> F
eqt₂(true, tuplenil₁(H2)) -> F
eqt₂(undefined, nil) -> F
eqt₂(undefined, a) -> F
eqt₂(undefined, tuplenil₁(H2)) -> F
eqt₂(pid₁(N1), nil) -> F
eqt₂(pid₁(N1), a) -> F
eqt₂(pid₁(N1), excl) -> F
eqt₂(pid₁(N1), false) -> F
eqt₂(pid₁(N1), lock) -> F
eqt₂(pid₁(N1), locker) -> F
eqt₂(pid₁(N1), mcrlrecord) -> F
eqt₂(pid₁(N1), ok) -> F
eqt₂(pid₁(N1), pending) -> F
eqt₂(pid₁(N1), release) -> F
eqt₂(pid₁(N1), request) -> F
eqt₂(pid₁(N1), resource) -> F
eqt₂(pid₁(N1), tag) -> F
eqt₂(pid₁(N1), true) -> F
eqt₂(pid₁(N1), undefined) -> F
eqt₂(pid₁(N1), pid₁(N2)) -> eqt₂(N1, N2)
eqt₂(pid₁(N1), int₁(N2)) -> F
eqt₂(pid₁(N1), cons₂(H2, T2)) -> F
eqt₂(pid₁(N1), tuple₂(H2, T2)) -> F
eqt₂(pid₁(N1), tuplenil₁(H2)) -> F
eqt₂(int₁(N1), nil) -> F
eqt₂(int₁(N1), a) -> F
eqt₂(int₁(N1), excl) -> F
eqt₂(int₁(N1), false) -> F
eqt₂(int₁(N1), lock) -> F
eqt₂(int₁(N1), locker) -> F
eqt₂(int₁(N1), mcrlrecord) -> F
eqt₂(int₁(N1), ok) -> F
eqt₂(int₁(N1), pending) -> F
eqt₂(int₁(N1), release) -> F
eqt₂(int₁(N1), request) -> F
eqt₂(int₁(N1), resource) -> F
eqt₂(int₁(N1), tag) -> F
eqt₂(int₁(N1), true) -> F
eqt₂(int₁(N1), undefined) -> F
eqt₂(cons₂(H1, T1), resource) -> F
eqt₂(cons₂(H1, T1), tag) -> F
eqt₂(cons₂(H1, T1), true) -> F
eqt₂(cons₂(H1, T1), undefined) -> F
eqt₂(cons₂(H1, T1), pid₁(N2)) -> F
eqt₂(cons₂(H1, T1), int₁(N2)) -> F
eqt₂(cons₂(H1, T1), cons₂(H2, T2)) -> and₂(eqt₂(H1, H2), eqt₂(T1, T2))
eqt₂(cons₂(H1, T1), tuple₂(H2, T2)) -> F
eqt₂(cons₂(H1, T1), tuplenil₁(H2)) -> F
eqt₂(tuple₂(H1, T1), nil) -> F
eqt₂(tuple₂(H1, T1), a) -> F
eqt₂(tuple₂(H1, T1), excl) -> F
eqt₂(tuple₂(H1, T1), false) -> F
eqt₂(tuple₂(H1, T1), lock) -> F
eqt₂(tuple₂(H1, T1), locker) -> F
eqt₂(tuple₂(H1, T1), mcrlrecord) -> F
eqt₂(tuple₂(H1, T1), ok) -> F
eqt₂(tuple₂(H1, T1), pending) -> F
eqt₂(tuple₂(H1, T1), release) -> F
eqt₂(tuple₂(H1, T1), request) -> F
eqt₂(tuple₂(H1, T1), resource) -> F
eqt₂(tuple₂(H1, T1), tag) -> F
eqt₂(tuple₂(H1, T1), true) -> F
eqt₂(tuple₂(H1, T1), undefined) -> F
eqt₂(tuple₂(H1, T1), pid₁(N2)) -> F
eqt₂(tuple₂(H1, T1), int₁(N2)) -> F
eqt₂(tuple₂(H1, T1), cons₂(H2, T2)) -> F
eqt₂(tuple₂(H1, T1), tuple₂(H2, T2)) -> and₂(eqt₂(H1, H2), eqt₂(T1, T2))
eqt₂(tuple₂(H1, T1), tuplenil₁(H2)) -> F
eqt₂(tuplenil₁(H1), nil) -> F
eqt₂(tuplenil₁(H1), a) -> F
eqt₂(tuplenil₁(H1), excl) -> F
eqt₂(tuplenil₁(H1), false) -> F
eqt₂(tuplenil₁(H1), lock) -> F
eqt₂(tuplenil₁(H1), locker) -> F
eqt₂(tuplenil₁(H1), mcrlrecord) -> F
eqt₂(tuplenil₁(H1), ok) -> F
eqt₂(tuplenil₁(H1), pending) -> F
eqt₂(tuplenil₁(H1), release) -> F
eqt₂(tuplenil₁(H1), request) -> F
eqt₂(tuplenil₁(H1), resource) -> F
eqt₂(tuplenil₁(H1), tag) -> F
eqt₂(tuplenil₁(H1), true) -> F
eqt₂(tuplenil₁(H1), undefined) -> F
eqt₂(tuplenil₁(H1), pid₁(N2)) -> F
eqt₂(tuplenil₁(H1), int₁(N2)) -> F
eqt₂(tuplenil₁(H1), cons₂(H2, T2)) -> F
eqt₂(tuplenil₁(H1), tuple₂(H2, T2)) -> F
eqt₂(tuplenil₁(H1), tuplenil₁(H2)) -> eqt₂(H1, H2)
element₂(int₁(s₁(0)), tuplenil₁(T1)) -> T1
element₂(int₁(s₁(0)), tuple₂(T1, T2)) -> T1
element₂(int₁(s₁(s₁(N1))), tuple₂(T1, T2)) -> element₂(int₁(s₁(N1)), T2)
record_new₁(lock) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(undefined, tuple₂(nil, tuplenil₁(nil)))))
record_extract₃(tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2))))), lock, resource) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2)))))
record_update₄(tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2))))), lock, pending, NewF) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(NewF)))))
record_updates₃(Record, Name, nil) -> Record
record_updates₃(Record, Name, cons₂(tuple₂(Field, tuplenil₁(NewF)), Fields)) -> record_updates₃(record_update₄(Record, Name, Field, NewF), Name, Fields)
locker2_map_promote_pending₂(nil, Pending) -> nil
locker2_map_promote_pending₂(cons₂(Lock, Locks), Pending) -> cons₂(locker2_promote_pending₂(Lock, Pending), locker2_map_promote_pending₂(Locks, Pending))
locker2_map_claim_lock₃(nil, Resources, Client) -> nil
locker2_map_claim_lock₃(cons₂(Lock, Locks), Resources, Client) -> cons₂(locker2_claim_lock₃(Lock, Resources, Client), locker2_map_claim_lock₃(Locks, Resources, Client))
locker2_map_add_pending₃(nil, Resources, Client) -> nil
locker2_promote_pending₂(Lock, Client) -> case0₃(Client, Lock, record_extract₃(Lock, lock, pending))
case0₃(Client, Lock, cons₂(Client, Pendings)) -> record_updates₃(Lock, lock, cons₂(tuple₂(excl, tuplenil₁(Client)), cons₂(tuple₂(pending, tuplenil₁(Pendings)), nil)))
case0₃(Client, Lock, MCRLFree0) -> Lock
locker2_remove_pending₂(Lock, Client) -> record_updates₃(Lock, lock, cons₂(tuple₂(pending, tuplenil₁(subtract₂(record_extract₃(Lock, lock, pending), cons₂(Client, nil)))), nil))
locker2_add_pending₃(Lock, Resources, Client) -> case1₄(Client, Resources, Lock, member₂(record_extract₃(Lock, lock, resource), Resources))
case1₄(Client, Resources, Lock, true) -> record_updates₃(Lock, lock, cons₂(tuple₂(pending, tuplenil₁(append₂(record_extract₃(Lock, lock, pending), cons₂(Client, nil)))), nil))
case1₄(Client, Resources, Lock, false) -> Lock
locker2_release_lock₂(Lock, Client) -> case2₃(Client, Lock, gen_modtageq₂(Client, record_extract₃(Lock, lock, excl)))
case2₃(Client, Lock, true) -> record_updates₃(Lock, lock, cons₂(tuple₂(excllock, excl), nil))
case4₃(Client, Lock, MCRLFree1) -> false
locker2_obtainables₂(nil, Client) -> true
locker2_obtainables₂(cons₂(Lock, Locks), Client) -> case5₄(Client, Locks, Lock, member₂(Client, record_extract₃(Lock, lock, pending)))
case5₄(Client, Locks, Lock, true) -> andt₂(locker2_obtainable₂(Lock, Client), locker2_obtainables₂(Locks, Client))
case5₄(Client, Locks, Lock, false) -> locker2_obtainables₂(Locks, Client)
locker2_check_available₂(Resource, nil) -> false
locker2_check_available₂(Resource, cons₂(Lock, Locks)) -> case6₄(Locks, Lock, Resource, equal₂(Resource, record_extract₃(Lock, lock, resource)))
case6₄(Locks, Lock, Resource, true) -> andt₂(equal₂(record_extract₃(Lock, lock, excl), nil), equal₂(record_extract₃(Lock, lock, pending), nil))
case6₄(Locks, Lock, Resource, false) -> locker2_check_available₂(Resource, Locks)
locker2_check_availables₂(nil, Locks) -> true
locker2_check_availables₂(cons₂(Resource, Resources), Locks) -> andt₂(locker2_check_available₂(Resource, Locks), locker2_check_availables₂(Resources, Locks))
locker2_adduniq₂(nil, List) -> List
append₂(cons₂(Head, Tail), List) -> cons₂(Head, append₂(Tail, List))
subtract₂(List, nil) -> List
subtract₂(List, cons₂(Head, Tail)) -> subtract₂(delete₂(Head, List), Tail)
delete₂(E, nil) -> nil
delete₂(E, cons₂(Head, Tail)) -> case8₄(Tail, Head, E, equal₂(E, Head))
case8₄(Tail, Head, E, true) -> Tail
case8₄(Tail, Head, E, false) -> cons₂(Head, delete₂(E, Tail))
gen_tag₁(Pid) -> tuple₂(Pid, tuplenil₁(tag))
gen_modtageq₂(Client1, Client2) -> equal₂(Client1, Client2)
member₂(E, nil) -> false
member₂(E, cons₂(Head, Tail)) -> case9₄(Tail, Head, E, equal₂(E, Head))
case9₄(Tail, Head, E, true) -> true
case9₄(Tail, Head, E, false) -> member₂(E, Tail)
eqs₂(empty, empty) -> T
eqs₂(empty, stack₂(E2, S2)) -> F
eqs₂(stack₂(E1, S1), empty) -> F
eqs₂(stack₂(E1, S1), stack₂(E2, S2)) -> and₂(eqt₂(E1, E2), eqs₂(S1, S2))
pushs₂(E1, S1) -> stack₂(E1, S1)
pops₁(stack₂(E1, S1)) -> S1
tops₁(stack₂(E1, S1)) -> E1
istops₂(E1, empty) -> F
istops₂(E1, stack₂(E2, S1)) -> eqt₂(E1, E2)
eqc₂(nocalls, nocalls) -> T
eqc₂(nocalls, calls₃(E2, S2, CS2)) -> F
eqc₂(calls₃(E1, S1, CS1), nocalls) -> F
eqc₂(calls₃(E1, S1, CS1), calls₃(E2, S2, CS2)) -> and₂(eqt₂(E1, E2), and₂(eqs₂(S1, S2), eqc₂(CS1, CS2)))
push₃(E1, E2, nocalls) -> calls₃(E1, stack₂(E2, empty), nocalls)
push₃(E1, E2, calls₃(E3, S1, CS1)) -> push1₆(E1, E2, E3, S1, CS1, eqt₂(E1, E3))
push1₆(E1, E2, E3, S1, CS1, T) -> calls₃(E3, pushs₂(E2, S1), CS1)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

LOCKER2_MAP_CLAIM_LOCK₃(cons₂(Lock, Locks), Resources, Client) -> LOCKER2_MAP_CLAIM_LOCK₃(Locks, Resources, Client)

The TRS R consists of the following rules:

or₂(T, T) -> T
or₂(F, T) -> T
or₂(T, F) -> T
or₂(F, F) -> F
and₂(T, B) -> B
and₂(B, T) -> B
and₂(F, B) -> F
and₂(B, F) -> F
imp₂(T, B) -> B
imp₂(F, B) -> T
not₁(T) -> F
not₁(F) -> T
if₃(T, B1, B2) -> B1
if₃(F, B1, B2) -> B2
eq₂(T, T) -> T
eq₂(F, F) -> T
eq₂(T, F) -> F
eq₂(F, T) -> F
eqt₂(nil, undefined) -> F
eqt₂(nil, pid₁(N2)) -> F
eqt₂(nil, int₁(N2)) -> F
eqt₂(nil, cons₂(H2, T2)) -> F
eqt₂(nil, tuple₂(H2, T2)) -> F
eqt₂(nil, tuplenil₁(H2)) -> F
eqt₂(a, nil) -> F
eqt₂(a, a) -> T
eqt₂(a, excl) -> F
eqt₂(a, false) -> F
eqt₂(a, lock) -> F
eqt₂(a, locker) -> F
eqt₂(a, mcrlrecord) -> F
eqt₂(a, ok) -> F
eqt₂(a, pending) -> F
eqt₂(a, release) -> F
eqt₂(a, request) -> F
eqt₂(a, resource) -> F
eqt₂(a, tag) -> F
eqt₂(a, true) -> F
eqt₂(a, undefined) -> F
eqt₂(a, pid₁(N2)) -> F
eqt₂(a, int₁(N2)) -> F
eqt₂(a, cons₂(H2, T2)) -> F
eqt₂(a, tuple₂(H2, T2)) -> F
eqt₂(a, tuplenil₁(H2)) -> F
eqt₂(excl, nil) -> F
eqt₂(excl, a) -> F
eqt₂(excl, excl) -> T
eqt₂(excl, false) -> F
eqt₂(excl, lock) -> F
eqt₂(excl, locker) -> F
eqt₂(excl, mcrlrecord) -> F
eqt₂(excl, ok) -> F
eqt₂(excl, pending) -> F
eqt₂(excl, release) -> F
eqt₂(excl, request) -> F
eqt₂(excl, resource) -> F
eqt₂(excl, tag) -> F
eqt₂(excl, true) -> F
eqt₂(excl, undefined) -> F
eqt₂(excl, pid₁(N2)) -> F
eqt₂(excl, eqt₂(false, int₁(N2))) -> F
eqt₂(false, cons₂(H2, T2)) -> F
eqt₂(false, tuple₂(H2, T2)) -> F
eqt₂(false, tuplenil₁(H2)) -> F
eqt₂(lock, nil) -> F
eqt₂(lock, a) -> F
eqt₂(lock, excl) -> F
eqt₂(lock, false) -> F
eqt₂(lock, lock) -> T
eqt₂(lock, locker) -> F
eqt₂(lock, mcrlrecord) -> F
eqt₂(lock, ok) -> F
eqt₂(lock, pending) -> F
eqt₂(lock, release) -> F
eqt₂(lock, request) -> F
eqt₂(lock, resource) -> F
eqt₂(lock, tag) -> F
eqt₂(lock, true) -> F
eqt₂(lock, undefined) -> F
eqt₂(lock, pid₁(N2)) -> F
eqt₂(lock, int₁(N2)) -> F
eqt₂(lock, cons₂(H2, T2)) -> F
eqt₂(lock, tuple₂(H2, T2)) -> F
eqt₂(lock, tuplenil₁(H2)) -> F
eqt₂(locker, nil) -> F
eqt₂(locker, a) -> F
eqt₂(locker, excl) -> F
eqt₂(locker, false) -> F
eqt₂(locker, lock) -> F
eqt₂(locker, locker) -> T
eqt₂(locker, mcrlrecord) -> F
eqt₂(locker, ok) -> F
eqt₂(locker, pending) -> F
eqt₂(locker, release) -> F
eqt₂(locker, request) -> F
eqt₂(locker, resource) -> F
eqt₂(locker, tag) -> F
eqt₂(locker, true) -> F
eqt₂(locker, undefined) -> F
eqt₂(locker, pid₁(N2)) -> F
eqt₂(locker, int₁(N2)) -> F
eqt₂(locker, cons₂(H2, T2)) -> F
eqt₂(locker, tuple₂(H2, T2)) -> F
eqt₂(locker, tuplenil₁(H2)) -> F
eqt₂(mcrlrecord, nil) -> F
eqt₂(mcrlrecord, a) -> F
eqt₂(mcrlrecord, excl) -> F
eqt₂(mcrlrecord, false) -> F
eqt₂(mcrlrecord, lock) -> F
eqt₂(mcrlrecord, locker) -> F
eqt₂(mcrlrecord, mcrlrecord) -> T
eqt₂(mcrlrecord, ok) -> F
eqt₂(mcrlrecord, pending) -> F
eqt₂(mcrlrecord, release) -> F
eqt₂(mcrlrecord, request) -> F
eqt₂(mcrlrecord, resource) -> F
eqt₂(ok, resource) -> F
eqt₂(ok, tag) -> F
eqt₂(ok, true) -> F
eqt₂(ok, undefined) -> F
eqt₂(ok, pid₁(N2)) -> F
eqt₂(ok, int₁(N2)) -> F
eqt₂(ok, cons₂(H2, T2)) -> F
eqt₂(ok, tuple₂(H2, T2)) -> F
eqt₂(ok, tuplenil₁(H2)) -> F
eqt₂(pending, nil) -> F
eqt₂(pending, a) -> F
eqt₂(pending, excl) -> F
eqt₂(pending, false) -> F
eqt₂(pending, lock) -> F
eqt₂(pending, locker) -> F
eqt₂(pending, mcrlrecord) -> F
eqt₂(pending, ok) -> F
eqt₂(pending, pending) -> T
eqt₂(pending, release) -> F
eqt₂(pending, request) -> F
eqt₂(pending, resource) -> F
eqt₂(pending, tag) -> F
eqt₂(pending, true) -> F
eqt₂(pending, undefined) -> F
eqt₂(pending, pid₁(N2)) -> F
eqt₂(pending, int₁(N2)) -> F
eqt₂(pending, cons₂(H2, T2)) -> F
eqt₂(pending, tuple₂(H2, T2)) -> F
eqt₂(pending, tuplenil₁(H2)) -> F
eqt₂(release, nil) -> F
eqt₂(release, a) -> F
eqt₂(release, excl) -> F
eqt₂(release, false) -> F
eqt₂(release, lock) -> F
eqt₂(release, locker) -> F
eqt₂(release, mcrlrecord) -> F
eqt₂(release, ok) -> F
eqt₂(request, mcrlrecord) -> F
eqt₂(request, ok) -> F
eqt₂(request, pending) -> F
eqt₂(request, release) -> F
eqt₂(request, request) -> T
eqt₂(request, resource) -> F
eqt₂(request, tag) -> F
eqt₂(request, true) -> F
eqt₂(request, undefined) -> F
eqt₂(request, pid₁(N2)) -> F
eqt₂(request, int₁(N2)) -> F
eqt₂(request, cons₂(H2, T2)) -> F
eqt₂(request, tuple₂(H2, T2)) -> F
eqt₂(request, tuplenil₁(H2)) -> F
eqt₂(resource, nil) -> F
eqt₂(resource, a) -> F
eqt₂(resource, excl) -> F
eqt₂(resource, false) -> F
eqt₂(resource, lock) -> F
eqt₂(resource, locker) -> F
eqt₂(resource, mcrlrecord) -> F
eqt₂(resource, ok) -> F
eqt₂(resource, pending) -> F
eqt₂(resource, release) -> F
eqt₂(resource, request) -> F
eqt₂(resource, resource) -> T
eqt₂(resource, tag) -> F
eqt₂(resource, true) -> F
eqt₂(resource, undefined) -> F
eqt₂(resource, pid₁(N2)) -> F
eqt₂(resource, int₁(N2)) -> F
eqt₂(resource, cons₂(H2, T2)) -> F
eqt₂(resource, tuple₂(H2, T2)) -> F
eqt₂(resource, tuplenil₁(H2)) -> F
eqt₂(tag, nil) -> F
eqt₂(tag, a) -> F
eqt₂(tag, excl) -> F
eqt₂(tag, false) -> F
eqt₂(tag, lock) -> F
eqt₂(tag, locker) -> F
eqt₂(tag, mcrlrecord) -> F
eqt₂(tag, ok) -> F
eqt₂(tag, pending) -> F
eqt₂(tag, release) -> F
eqt₂(tag, request) -> F
eqt₂(tag, resource) -> F
eqt₂(tag, tag) -> T
eqt₂(tag, true) -> F
eqt₂(tag, undefined) -> F
eqt₂(tag, pid₁(N2)) -> F
eqt₂(tag, int₁(N2)) -> F
eqt₂(tag, cons₂(H2, T2)) -> F
eqt₂(tag, tuple₂(H2, T2)) -> F
eqt₂(tag, tuplenil₁(H2)) -> F
eqt₂(true, nil) -> F
eqt₂(true, a) -> F
eqt₂(true, excl) -> F
eqt₂(true, false) -> F
eqt₂(true, lock) -> F
eqt₂(true, locker) -> F
eqt₂(true, mcrlrecord) -> F
eqt₂(true, ok) -> F
eqt₂(true, pending) -> F
eqt₂(true, release) -> F
eqt₂(true, request) -> F
eqt₂(true, resource) -> F
eqt₂(true, tag) -> F
eqt₂(true, true) -> T
eqt₂(true, undefined) -> F
eqt₂(true, pid₁(N2)) -> F
eqt₂(true, int₁(N2)) -> F
eqt₂(true, cons₂(H2, T2)) -> F
eqt₂(true, tuple₂(H2, T2)) -> F
eqt₂(true, tuplenil₁(H2)) -> F
eqt₂(undefined, nil) -> F
eqt₂(undefined, a) -> F
eqt₂(undefined, tuplenil₁(H2)) -> F
eqt₂(pid₁(N1), nil) -> F
eqt₂(pid₁(N1), a) -> F
eqt₂(pid₁(N1), excl) -> F
eqt₂(pid₁(N1), false) -> F
eqt₂(pid₁(N1), lock) -> F
eqt₂(pid₁(N1), locker) -> F
eqt₂(pid₁(N1), mcrlrecord) -> F
eqt₂(pid₁(N1), ok) -> F
eqt₂(pid₁(N1), pending) -> F
eqt₂(pid₁(N1), release) -> F
eqt₂(pid₁(N1), request) -> F
eqt₂(pid₁(N1), resource) -> F
eqt₂(pid₁(N1), tag) -> F
eqt₂(pid₁(N1), true) -> F
eqt₂(pid₁(N1), undefined) -> F
eqt₂(pid₁(N1), pid₁(N2)) -> eqt₂(N1, N2)
eqt₂(pid₁(N1), int₁(N2)) -> F
eqt₂(pid₁(N1), cons₂(H2, T2)) -> F
eqt₂(pid₁(N1), tuple₂(H2, T2)) -> F
eqt₂(pid₁(N1), tuplenil₁(H2)) -> F
eqt₂(int₁(N1), nil) -> F
eqt₂(int₁(N1), a) -> F
eqt₂(int₁(N1), excl) -> F
eqt₂(int₁(N1), false) -> F
eqt₂(int₁(N1), lock) -> F
eqt₂(int₁(N1), locker) -> F
eqt₂(int₁(N1), mcrlrecord) -> F
eqt₂(int₁(N1), ok) -> F
eqt₂(int₁(N1), pending) -> F
eqt₂(int₁(N1), release) -> F
eqt₂(int₁(N1), request) -> F
eqt₂(int₁(N1), resource) -> F
eqt₂(int₁(N1), tag) -> F
eqt₂(int₁(N1), true) -> F
eqt₂(int₁(N1), undefined) -> F
eqt₂(cons₂(H1, T1), resource) -> F
eqt₂(cons₂(H1, T1), tag) -> F
eqt₂(cons₂(H1, T1), true) -> F
eqt₂(cons₂(H1, T1), undefined) -> F
eqt₂(cons₂(H1, T1), pid₁(N2)) -> F
eqt₂(cons₂(H1, T1), int₁(N2)) -> F
eqt₂(cons₂(H1, T1), cons₂(H2, T2)) -> and₂(eqt₂(H1, H2), eqt₂(T1, T2))
eqt₂(cons₂(H1, T1), tuple₂(H2, T2)) -> F
eqt₂(cons₂(H1, T1), tuplenil₁(H2)) -> F
eqt₂(tuple₂(H1, T1), nil) -> F
eqt₂(tuple₂(H1, T1), a) -> F
eqt₂(tuple₂(H1, T1), excl) -> F
eqt₂(tuple₂(H1, T1), false) -> F
eqt₂(tuple₂(H1, T1), lock) -> F
eqt₂(tuple₂(H1, T1), locker) -> F
eqt₂(tuple₂(H1, T1), mcrlrecord) -> F
eqt₂(tuple₂(H1, T1), ok) -> F
eqt₂(tuple₂(H1, T1), pending) -> F
eqt₂(tuple₂(H1, T1), release) -> F
eqt₂(tuple₂(H1, T1), request) -> F
eqt₂(tuple₂(H1, T1), resource) -> F
eqt₂(tuple₂(H1, T1), tag) -> F
eqt₂(tuple₂(H1, T1), true) -> F
eqt₂(tuple₂(H1, T1), undefined) -> F
eqt₂(tuple₂(H1, T1), pid₁(N2)) -> F
eqt₂(tuple₂(H1, T1), int₁(N2)) -> F
eqt₂(tuple₂(H1, T1), cons₂(H2, T2)) -> F
eqt₂(tuple₂(H1, T1), tuple₂(H2, T2)) -> and₂(eqt₂(H1, H2), eqt₂(T1, T2))
eqt₂(tuple₂(H1, T1), tuplenil₁(H2)) -> F
eqt₂(tuplenil₁(H1), nil) -> F
eqt₂(tuplenil₁(H1), a) -> F
eqt₂(tuplenil₁(H1), excl) -> F
eqt₂(tuplenil₁(H1), false) -> F
eqt₂(tuplenil₁(H1), lock) -> F
eqt₂(tuplenil₁(H1), locker) -> F
eqt₂(tuplenil₁(H1), mcrlrecord) -> F
eqt₂(tuplenil₁(H1), ok) -> F
eqt₂(tuplenil₁(H1), pending) -> F
eqt₂(tuplenil₁(H1), release) -> F
eqt₂(tuplenil₁(H1), request) -> F
eqt₂(tuplenil₁(H1), resource) -> F
eqt₂(tuplenil₁(H1), tag) -> F
eqt₂(tuplenil₁(H1), true) -> F
eqt₂(tuplenil₁(H1), undefined) -> F
eqt₂(tuplenil₁(H1), pid₁(N2)) -> F
eqt₂(tuplenil₁(H1), int₁(N2)) -> F
eqt₂(tuplenil₁(H1), cons₂(H2, T2)) -> F
eqt₂(tuplenil₁(H1), tuple₂(H2, T2)) -> F
eqt₂(tuplenil₁(H1), tuplenil₁(H2)) -> eqt₂(H1, H2)
element₂(int₁(s₁(0)), tuplenil₁(T1)) -> T1
element₂(int₁(s₁(0)), tuple₂(T1, T2)) -> T1
element₂(int₁(s₁(s₁(N1))), tuple₂(T1, T2)) -> element₂(int₁(s₁(N1)), T2)
record_new₁(lock) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(undefined, tuple₂(nil, tuplenil₁(nil)))))
record_extract₃(tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2))))), lock, resource) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2)))))
record_update₄(tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2))))), lock, pending, NewF) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(NewF)))))
record_updates₃(Record, Name, nil) -> Record
record_updates₃(Record, Name, cons₂(tuple₂(Field, tuplenil₁(NewF)), Fields)) -> record_updates₃(record_update₄(Record, Name, Field, NewF), Name, Fields)
locker2_map_promote_pending₂(nil, Pending) -> nil
locker2_map_promote_pending₂(cons₂(Lock, Locks), Pending) -> cons₂(locker2_promote_pending₂(Lock, Pending), locker2_map_promote_pending₂(Locks, Pending))
locker2_map_claim_lock₃(nil, Resources, Client) -> nil
locker2_map_claim_lock₃(cons₂(Lock, Locks), Resources, Client) -> cons₂(locker2_claim_lock₃(Lock, Resources, Client), locker2_map_claim_lock₃(Locks, Resources, Client))
locker2_map_add_pending₃(nil, Resources, Client) -> nil
locker2_promote_pending₂(Lock, Client) -> case0₃(Client, Lock, record_extract₃(Lock, lock, pending))
case0₃(Client, Lock, cons₂(Client, Pendings)) -> record_updates₃(Lock, lock, cons₂(tuple₂(excl, tuplenil₁(Client)), cons₂(tuple₂(pending, tuplenil₁(Pendings)), nil)))
case0₃(Client, Lock, MCRLFree0) -> Lock
locker2_remove_pending₂(Lock, Client) -> record_updates₃(Lock, lock, cons₂(tuple₂(pending, tuplenil₁(subtract₂(record_extract₃(Lock, lock, pending), cons₂(Client, nil)))), nil))
locker2_add_pending₃(Lock, Resources, Client) -> case1₄(Client, Resources, Lock, member₂(record_extract₃(Lock, lock, resource), Resources))
case1₄(Client, Resources, Lock, true) -> record_updates₃(Lock, lock, cons₂(tuple₂(pending, tuplenil₁(append₂(record_extract₃(Lock, lock, pending), cons₂(Client, nil)))), nil))
case1₄(Client, Resources, Lock, false) -> Lock
locker2_release_lock₂(Lock, Client) -> case2₃(Client, Lock, gen_modtageq₂(Client, record_extract₃(Lock, lock, excl)))
case2₃(Client, Lock, true) -> record_updates₃(Lock, lock, cons₂(tuple₂(excllock, excl), nil))
case4₃(Client, Lock, MCRLFree1) -> false
locker2_obtainables₂(nil, Client) -> true
locker2_obtainables₂(cons₂(Lock, Locks), Client) -> case5₄(Client, Locks, Lock, member₂(Client, record_extract₃(Lock, lock, pending)))
case5₄(Client, Locks, Lock, true) -> andt₂(locker2_obtainable₂(Lock, Client), locker2_obtainables₂(Locks, Client))
case5₄(Client, Locks, Lock, false) -> locker2_obtainables₂(Locks, Client)
locker2_check_available₂(Resource, nil) -> false
locker2_check_available₂(Resource, cons₂(Lock, Locks)) -> case6₄(Locks, Lock, Resource, equal₂(Resource, record_extract₃(Lock, lock, resource)))
case6₄(Locks, Lock, Resource, true) -> andt₂(equal₂(record_extract₃(Lock, lock, excl), nil), equal₂(record_extract₃(Lock, lock, pending), nil))
case6₄(Locks, Lock, Resource, false) -> locker2_check_available₂(Resource, Locks)
locker2_check_availables₂(nil, Locks) -> true
locker2_check_availables₂(cons₂(Resource, Resources), Locks) -> andt₂(locker2_check_available₂(Resource, Locks), locker2_check_availables₂(Resources, Locks))
locker2_adduniq₂(nil, List) -> List
append₂(cons₂(Head, Tail), List) -> cons₂(Head, append₂(Tail, List))
subtract₂(List, nil) -> List
subtract₂(List, cons₂(Head, Tail)) -> subtract₂(delete₂(Head, List), Tail)
delete₂(E, nil) -> nil
delete₂(E, cons₂(Head, Tail)) -> case8₄(Tail, Head, E, equal₂(E, Head))
case8₄(Tail, Head, E, true) -> Tail
case8₄(Tail, Head, E, false) -> cons₂(Head, delete₂(E, Tail))
gen_tag₁(Pid) -> tuple₂(Pid, tuplenil₁(tag))
gen_modtageq₂(Client1, Client2) -> equal₂(Client1, Client2)
member₂(E, nil) -> false
member₂(E, cons₂(Head, Tail)) -> case9₄(Tail, Head, E, equal₂(E, Head))
case9₄(Tail, Head, E, true) -> true
case9₄(Tail, Head, E, false) -> member₂(E, Tail)
eqs₂(empty, empty) -> T
eqs₂(empty, stack₂(E2, S2)) -> F
eqs₂(stack₂(E1, S1), empty) -> F
eqs₂(stack₂(E1, S1), stack₂(E2, S2)) -> and₂(eqt₂(E1, E2), eqs₂(S1, S2))
pushs₂(E1, S1) -> stack₂(E1, S1)
pops₁(stack₂(E1, S1)) -> S1
tops₁(stack₂(E1, S1)) -> E1
istops₂(E1, empty) -> F
istops₂(E1, stack₂(E2, S1)) -> eqt₂(E1, E2)
eqc₂(nocalls, nocalls) -> T
eqc₂(nocalls, calls₃(E2, S2, CS2)) -> F
eqc₂(calls₃(E1, S1, CS1), nocalls) -> F
eqc₂(calls₃(E1, S1, CS1), calls₃(E2, S2, CS2)) -> and₂(eqt₂(E1, E2), and₂(eqs₂(S1, S2), eqc₂(CS1, CS2)))
push₃(E1, E2, nocalls) -> calls₃(E1, stack₂(E2, empty), nocalls)
push₃(E1, E2, calls₃(E3, S1, CS1)) -> push1₆(E1, E2, E3, S1, CS1, eqt₂(E1, E3))
push1₆(E1, E2, E3, S1, CS1, T) -> calls₃(E3, pushs₂(E2, S1), CS1)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

LOCKER2_MAP_CLAIM_LOCK₃(cons₂(Lock, Locks), Resources, Client) -> LOCKER2_MAP_CLAIM_LOCK₃(Locks, Resources, Client)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial Order [17,21] with Interpretation:

POL( LOCKER2_MAP_CLAIM_LOCK₃(x₁, ..., x₃) ) = x₁ + x₃

POL( cons₂(x₁, x₂) ) = x₁ + x₂ + 1

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

or₂(T, T) -> T
or₂(F, T) -> T
or₂(T, F) -> T
or₂(F, F) -> F
and₂(T, B) -> B
and₂(B, T) -> B
and₂(F, B) -> F
and₂(B, F) -> F
imp₂(T, B) -> B
imp₂(F, B) -> T
not₁(T) -> F
not₁(F) -> T
if₃(T, B1, B2) -> B1
if₃(F, B1, B2) -> B2
eq₂(T, T) -> T
eq₂(F, F) -> T
eq₂(T, F) -> F
eq₂(F, T) -> F
eqt₂(nil, undefined) -> F
eqt₂(nil, pid₁(N2)) -> F
eqt₂(nil, int₁(N2)) -> F
eqt₂(nil, cons₂(H2, T2)) -> F
eqt₂(nil, tuple₂(H2, T2)) -> F
eqt₂(nil, tuplenil₁(H2)) -> F
eqt₂(a, nil) -> F
eqt₂(a, a) -> T
eqt₂(a, excl) -> F
eqt₂(a, false) -> F
eqt₂(a, lock) -> F
eqt₂(a, locker) -> F
eqt₂(a, mcrlrecord) -> F
eqt₂(a, ok) -> F
eqt₂(a, pending) -> F
eqt₂(a, release) -> F
eqt₂(a, request) -> F
eqt₂(a, resource) -> F
eqt₂(a, tag) -> F
eqt₂(a, true) -> F
eqt₂(a, undefined) -> F
eqt₂(a, pid₁(N2)) -> F
eqt₂(a, int₁(N2)) -> F
eqt₂(a, cons₂(H2, T2)) -> F
eqt₂(a, tuple₂(H2, T2)) -> F
eqt₂(a, tuplenil₁(H2)) -> F
eqt₂(excl, nil) -> F
eqt₂(excl, a) -> F
eqt₂(excl, excl) -> T
eqt₂(excl, false) -> F
eqt₂(excl, lock) -> F
eqt₂(excl, locker) -> F
eqt₂(excl, mcrlrecord) -> F
eqt₂(excl, ok) -> F
eqt₂(excl, pending) -> F
eqt₂(excl, release) -> F
eqt₂(excl, request) -> F
eqt₂(excl, resource) -> F
eqt₂(excl, tag) -> F
eqt₂(excl, true) -> F
eqt₂(excl, undefined) -> F
eqt₂(excl, pid₁(N2)) -> F
eqt₂(excl, eqt₂(false, int₁(N2))) -> F
eqt₂(false, cons₂(H2, T2)) -> F
eqt₂(false, tuple₂(H2, T2)) -> F
eqt₂(false, tuplenil₁(H2)) -> F
eqt₂(lock, nil) -> F
eqt₂(lock, a) -> F
eqt₂(lock, excl) -> F
eqt₂(lock, false) -> F
eqt₂(lock, lock) -> T
eqt₂(lock, locker) -> F
eqt₂(lock, mcrlrecord) -> F
eqt₂(lock, ok) -> F
eqt₂(lock, pending) -> F
eqt₂(lock, release) -> F
eqt₂(lock, request) -> F
eqt₂(lock, resource) -> F
eqt₂(lock, tag) -> F
eqt₂(lock, true) -> F
eqt₂(lock, undefined) -> F
eqt₂(lock, pid₁(N2)) -> F
eqt₂(lock, int₁(N2)) -> F
eqt₂(lock, cons₂(H2, T2)) -> F
eqt₂(lock, tuple₂(H2, T2)) -> F
eqt₂(lock, tuplenil₁(H2)) -> F
eqt₂(locker, nil) -> F
eqt₂(locker, a) -> F
eqt₂(locker, excl) -> F
eqt₂(locker, false) -> F
eqt₂(locker, lock) -> F
eqt₂(locker, locker) -> T
eqt₂(locker, mcrlrecord) -> F
eqt₂(locker, ok) -> F
eqt₂(locker, pending) -> F
eqt₂(locker, release) -> F
eqt₂(locker, request) -> F
eqt₂(locker, resource) -> F
eqt₂(locker, tag) -> F
eqt₂(locker, true) -> F
eqt₂(locker, undefined) -> F
eqt₂(locker, pid₁(N2)) -> F
eqt₂(locker, int₁(N2)) -> F
eqt₂(locker, cons₂(H2, T2)) -> F
eqt₂(locker, tuple₂(H2, T2)) -> F
eqt₂(locker, tuplenil₁(H2)) -> F
eqt₂(mcrlrecord, nil) -> F
eqt₂(mcrlrecord, a) -> F
eqt₂(mcrlrecord, excl) -> F
eqt₂(mcrlrecord, false) -> F
eqt₂(mcrlrecord, lock) -> F
eqt₂(mcrlrecord, locker) -> F
eqt₂(mcrlrecord, mcrlrecord) -> T
eqt₂(mcrlrecord, ok) -> F
eqt₂(mcrlrecord, pending) -> F
eqt₂(mcrlrecord, release) -> F
eqt₂(mcrlrecord, request) -> F
eqt₂(mcrlrecord, resource) -> F
eqt₂(ok, resource) -> F
eqt₂(ok, tag) -> F
eqt₂(ok, true) -> F
eqt₂(ok, undefined) -> F
eqt₂(ok, pid₁(N2)) -> F
eqt₂(ok, int₁(N2)) -> F
eqt₂(ok, cons₂(H2, T2)) -> F
eqt₂(ok, tuple₂(H2, T2)) -> F
eqt₂(ok, tuplenil₁(H2)) -> F
eqt₂(pending, nil) -> F
eqt₂(pending, a) -> F
eqt₂(pending, excl) -> F
eqt₂(pending, false) -> F
eqt₂(pending, lock) -> F
eqt₂(pending, locker) -> F
eqt₂(pending, mcrlrecord) -> F
eqt₂(pending, ok) -> F
eqt₂(pending, pending) -> T
eqt₂(pending, release) -> F
eqt₂(pending, request) -> F
eqt₂(pending, resource) -> F
eqt₂(pending, tag) -> F
eqt₂(pending, true) -> F
eqt₂(pending, undefined) -> F
eqt₂(pending, pid₁(N2)) -> F
eqt₂(pending, int₁(N2)) -> F
eqt₂(pending, cons₂(H2, T2)) -> F
eqt₂(pending, tuple₂(H2, T2)) -> F
eqt₂(pending, tuplenil₁(H2)) -> F
eqt₂(release, nil) -> F
eqt₂(release, a) -> F
eqt₂(release, excl) -> F
eqt₂(release, false) -> F
eqt₂(release, lock) -> F
eqt₂(release, locker) -> F
eqt₂(release, mcrlrecord) -> F
eqt₂(release, ok) -> F
eqt₂(request, mcrlrecord) -> F
eqt₂(request, ok) -> F
eqt₂(request, pending) -> F
eqt₂(request, release) -> F
eqt₂(request, request) -> T
eqt₂(request, resource) -> F
eqt₂(request, tag) -> F
eqt₂(request, true) -> F
eqt₂(request, undefined) -> F
eqt₂(request, pid₁(N2)) -> F
eqt₂(request, int₁(N2)) -> F
eqt₂(request, cons₂(H2, T2)) -> F
eqt₂(request, tuple₂(H2, T2)) -> F
eqt₂(request, tuplenil₁(H2)) -> F
eqt₂(resource, nil) -> F
eqt₂(resource, a) -> F
eqt₂(resource, excl) -> F
eqt₂(resource, false) -> F
eqt₂(resource, lock) -> F
eqt₂(resource, locker) -> F
eqt₂(resource, mcrlrecord) -> F
eqt₂(resource, ok) -> F
eqt₂(resource, pending) -> F
eqt₂(resource, release) -> F
eqt₂(resource, request) -> F
eqt₂(resource, resource) -> T
eqt₂(resource, tag) -> F
eqt₂(resource, true) -> F
eqt₂(resource, undefined) -> F
eqt₂(resource, pid₁(N2)) -> F
eqt₂(resource, int₁(N2)) -> F
eqt₂(resource, cons₂(H2, T2)) -> F
eqt₂(resource, tuple₂(H2, T2)) -> F
eqt₂(resource, tuplenil₁(H2)) -> F
eqt₂(tag, nil) -> F
eqt₂(tag, a) -> F
eqt₂(tag, excl) -> F
eqt₂(tag, false) -> F
eqt₂(tag, lock) -> F
eqt₂(tag, locker) -> F
eqt₂(tag, mcrlrecord) -> F
eqt₂(tag, ok) -> F
eqt₂(tag, pending) -> F
eqt₂(tag, release) -> F
eqt₂(tag, request) -> F
eqt₂(tag, resource) -> F
eqt₂(tag, tag) -> T
eqt₂(tag, true) -> F
eqt₂(tag, undefined) -> F
eqt₂(tag, pid₁(N2)) -> F
eqt₂(tag, int₁(N2)) -> F
eqt₂(tag, cons₂(H2, T2)) -> F
eqt₂(tag, tuple₂(H2, T2)) -> F
eqt₂(tag, tuplenil₁(H2)) -> F
eqt₂(true, nil) -> F
eqt₂(true, a) -> F
eqt₂(true, excl) -> F
eqt₂(true, false) -> F
eqt₂(true, lock) -> F
eqt₂(true, locker) -> F
eqt₂(true, mcrlrecord) -> F
eqt₂(true, ok) -> F
eqt₂(true, pending) -> F
eqt₂(true, release) -> F
eqt₂(true, request) -> F
eqt₂(true, resource) -> F
eqt₂(true, tag) -> F
eqt₂(true, true) -> T
eqt₂(true, undefined) -> F
eqt₂(true, pid₁(N2)) -> F
eqt₂(true, int₁(N2)) -> F
eqt₂(true, cons₂(H2, T2)) -> F
eqt₂(true, tuple₂(H2, T2)) -> F
eqt₂(true, tuplenil₁(H2)) -> F
eqt₂(undefined, nil) -> F
eqt₂(undefined, a) -> F
eqt₂(undefined, tuplenil₁(H2)) -> F
eqt₂(pid₁(N1), nil) -> F
eqt₂(pid₁(N1), a) -> F
eqt₂(pid₁(N1), excl) -> F
eqt₂(pid₁(N1), false) -> F
eqt₂(pid₁(N1), lock) -> F
eqt₂(pid₁(N1), locker) -> F
eqt₂(pid₁(N1), mcrlrecord) -> F
eqt₂(pid₁(N1), ok) -> F
eqt₂(pid₁(N1), pending) -> F
eqt₂(pid₁(N1), release) -> F
eqt₂(pid₁(N1), request) -> F
eqt₂(pid₁(N1), resource) -> F
eqt₂(pid₁(N1), tag) -> F
eqt₂(pid₁(N1), true) -> F
eqt₂(pid₁(N1), undefined) -> F
eqt₂(pid₁(N1), pid₁(N2)) -> eqt₂(N1, N2)
eqt₂(pid₁(N1), int₁(N2)) -> F
eqt₂(pid₁(N1), cons₂(H2, T2)) -> F
eqt₂(pid₁(N1), tuple₂(H2, T2)) -> F
eqt₂(pid₁(N1), tuplenil₁(H2)) -> F
eqt₂(int₁(N1), nil) -> F
eqt₂(int₁(N1), a) -> F
eqt₂(int₁(N1), excl) -> F
eqt₂(int₁(N1), false) -> F
eqt₂(int₁(N1), lock) -> F
eqt₂(int₁(N1), locker) -> F
eqt₂(int₁(N1), mcrlrecord) -> F
eqt₂(int₁(N1), ok) -> F
eqt₂(int₁(N1), pending) -> F
eqt₂(int₁(N1), release) -> F
eqt₂(int₁(N1), request) -> F
eqt₂(int₁(N1), resource) -> F
eqt₂(int₁(N1), tag) -> F
eqt₂(int₁(N1), true) -> F
eqt₂(int₁(N1), undefined) -> F
eqt₂(cons₂(H1, T1), resource) -> F
eqt₂(cons₂(H1, T1), tag) -> F
eqt₂(cons₂(H1, T1), true) -> F
eqt₂(cons₂(H1, T1), undefined) -> F
eqt₂(cons₂(H1, T1), pid₁(N2)) -> F
eqt₂(cons₂(H1, T1), int₁(N2)) -> F
eqt₂(cons₂(H1, T1), cons₂(H2, T2)) -> and₂(eqt₂(H1, H2), eqt₂(T1, T2))
eqt₂(cons₂(H1, T1), tuple₂(H2, T2)) -> F
eqt₂(cons₂(H1, T1), tuplenil₁(H2)) -> F
eqt₂(tuple₂(H1, T1), nil) -> F
eqt₂(tuple₂(H1, T1), a) -> F
eqt₂(tuple₂(H1, T1), excl) -> F
eqt₂(tuple₂(H1, T1), false) -> F
eqt₂(tuple₂(H1, T1), lock) -> F
eqt₂(tuple₂(H1, T1), locker) -> F
eqt₂(tuple₂(H1, T1), mcrlrecord) -> F
eqt₂(tuple₂(H1, T1), ok) -> F
eqt₂(tuple₂(H1, T1), pending) -> F
eqt₂(tuple₂(H1, T1), release) -> F
eqt₂(tuple₂(H1, T1), request) -> F
eqt₂(tuple₂(H1, T1), resource) -> F
eqt₂(tuple₂(H1, T1), tag) -> F
eqt₂(tuple₂(H1, T1), true) -> F
eqt₂(tuple₂(H1, T1), undefined) -> F
eqt₂(tuple₂(H1, T1), pid₁(N2)) -> F
eqt₂(tuple₂(H1, T1), int₁(N2)) -> F
eqt₂(tuple₂(H1, T1), cons₂(H2, T2)) -> F
eqt₂(tuple₂(H1, T1), tuple₂(H2, T2)) -> and₂(eqt₂(H1, H2), eqt₂(T1, T2))
eqt₂(tuple₂(H1, T1), tuplenil₁(H2)) -> F
eqt₂(tuplenil₁(H1), nil) -> F
eqt₂(tuplenil₁(H1), a) -> F
eqt₂(tuplenil₁(H1), excl) -> F
eqt₂(tuplenil₁(H1), false) -> F
eqt₂(tuplenil₁(H1), lock) -> F
eqt₂(tuplenil₁(H1), locker) -> F
eqt₂(tuplenil₁(H1), mcrlrecord) -> F
eqt₂(tuplenil₁(H1), ok) -> F
eqt₂(tuplenil₁(H1), pending) -> F
eqt₂(tuplenil₁(H1), release) -> F
eqt₂(tuplenil₁(H1), request) -> F
eqt₂(tuplenil₁(H1), resource) -> F
eqt₂(tuplenil₁(H1), tag) -> F
eqt₂(tuplenil₁(H1), true) -> F
eqt₂(tuplenil₁(H1), undefined) -> F
eqt₂(tuplenil₁(H1), pid₁(N2)) -> F
eqt₂(tuplenil₁(H1), int₁(N2)) -> F
eqt₂(tuplenil₁(H1), cons₂(H2, T2)) -> F
eqt₂(tuplenil₁(H1), tuple₂(H2, T2)) -> F
eqt₂(tuplenil₁(H1), tuplenil₁(H2)) -> eqt₂(H1, H2)
element₂(int₁(s₁(0)), tuplenil₁(T1)) -> T1
element₂(int₁(s₁(0)), tuple₂(T1, T2)) -> T1
element₂(int₁(s₁(s₁(N1))), tuple₂(T1, T2)) -> element₂(int₁(s₁(N1)), T2)
record_new₁(lock) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(undefined, tuple₂(nil, tuplenil₁(nil)))))
record_extract₃(tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2))))), lock, resource) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2)))))
record_update₄(tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2))))), lock, pending, NewF) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(NewF)))))
record_updates₃(Record, Name, nil) -> Record
record_updates₃(Record, Name, cons₂(tuple₂(Field, tuplenil₁(NewF)), Fields)) -> record_updates₃(record_update₄(Record, Name, Field, NewF), Name, Fields)
locker2_map_promote_pending₂(nil, Pending) -> nil
locker2_map_promote_pending₂(cons₂(Lock, Locks), Pending) -> cons₂(locker2_promote_pending₂(Lock, Pending), locker2_map_promote_pending₂(Locks, Pending))
locker2_map_claim_lock₃(nil, Resources, Client) -> nil
locker2_map_claim_lock₃(cons₂(Lock, Locks), Resources, Client) -> cons₂(locker2_claim_lock₃(Lock, Resources, Client), locker2_map_claim_lock₃(Locks, Resources, Client))
locker2_map_add_pending₃(nil, Resources, Client) -> nil
locker2_promote_pending₂(Lock, Client) -> case0₃(Client, Lock, record_extract₃(Lock, lock, pending))
case0₃(Client, Lock, cons₂(Client, Pendings)) -> record_updates₃(Lock, lock, cons₂(tuple₂(excl, tuplenil₁(Client)), cons₂(tuple₂(pending, tuplenil₁(Pendings)), nil)))
case0₃(Client, Lock, MCRLFree0) -> Lock
locker2_remove_pending₂(Lock, Client) -> record_updates₃(Lock, lock, cons₂(tuple₂(pending, tuplenil₁(subtract₂(record_extract₃(Lock, lock, pending), cons₂(Client, nil)))), nil))
locker2_add_pending₃(Lock, Resources, Client) -> case1₄(Client, Resources, Lock, member₂(record_extract₃(Lock, lock, resource), Resources))
case1₄(Client, Resources, Lock, true) -> record_updates₃(Lock, lock, cons₂(tuple₂(pending, tuplenil₁(append₂(record_extract₃(Lock, lock, pending), cons₂(Client, nil)))), nil))
case1₄(Client, Resources, Lock, false) -> Lock
locker2_release_lock₂(Lock, Client) -> case2₃(Client, Lock, gen_modtageq₂(Client, record_extract₃(Lock, lock, excl)))
case2₃(Client, Lock, true) -> record_updates₃(Lock, lock, cons₂(tuple₂(excllock, excl), nil))
case4₃(Client, Lock, MCRLFree1) -> false
locker2_obtainables₂(nil, Client) -> true
locker2_obtainables₂(cons₂(Lock, Locks), Client) -> case5₄(Client, Locks, Lock, member₂(Client, record_extract₃(Lock, lock, pending)))
case5₄(Client, Locks, Lock, true) -> andt₂(locker2_obtainable₂(Lock, Client), locker2_obtainables₂(Locks, Client))
case5₄(Client, Locks, Lock, false) -> locker2_obtainables₂(Locks, Client)
locker2_check_available₂(Resource, nil) -> false
locker2_check_available₂(Resource, cons₂(Lock, Locks)) -> case6₄(Locks, Lock, Resource, equal₂(Resource, record_extract₃(Lock, lock, resource)))
case6₄(Locks, Lock, Resource, true) -> andt₂(equal₂(record_extract₃(Lock, lock, excl), nil), equal₂(record_extract₃(Lock, lock, pending), nil))
case6₄(Locks, Lock, Resource, false) -> locker2_check_available₂(Resource, Locks)
locker2_check_availables₂(nil, Locks) -> true
locker2_check_availables₂(cons₂(Resource, Resources), Locks) -> andt₂(locker2_check_available₂(Resource, Locks), locker2_check_availables₂(Resources, Locks))
locker2_adduniq₂(nil, List) -> List
append₂(cons₂(Head, Tail), List) -> cons₂(Head, append₂(Tail, List))
subtract₂(List, nil) -> List
subtract₂(List, cons₂(Head, Tail)) -> subtract₂(delete₂(Head, List), Tail)
delete₂(E, nil) -> nil
delete₂(E, cons₂(Head, Tail)) -> case8₄(Tail, Head, E, equal₂(E, Head))
case8₄(Tail, Head, E, true) -> Tail
case8₄(Tail, Head, E, false) -> cons₂(Head, delete₂(E, Tail))
gen_tag₁(Pid) -> tuple₂(Pid, tuplenil₁(tag))
gen_modtageq₂(Client1, Client2) -> equal₂(Client1, Client2)
member₂(E, nil) -> false
member₂(E, cons₂(Head, Tail)) -> case9₄(Tail, Head, E, equal₂(E, Head))
case9₄(Tail, Head, E, true) -> true
case9₄(Tail, Head, E, false) -> member₂(E, Tail)
eqs₂(empty, empty) -> T
eqs₂(empty, stack₂(E2, S2)) -> F
eqs₂(stack₂(E1, S1), empty) -> F
eqs₂(stack₂(E1, S1), stack₂(E2, S2)) -> and₂(eqt₂(E1, E2), eqs₂(S1, S2))
pushs₂(E1, S1) -> stack₂(E1, S1)
pops₁(stack₂(E1, S1)) -> S1
tops₁(stack₂(E1, S1)) -> E1
istops₂(E1, empty) -> F
istops₂(E1, stack₂(E2, S1)) -> eqt₂(E1, E2)
eqc₂(nocalls, nocalls) -> T
eqc₂(nocalls, calls₃(E2, S2, CS2)) -> F
eqc₂(calls₃(E1, S1, CS1), nocalls) -> F
eqc₂(calls₃(E1, S1, CS1), calls₃(E2, S2, CS2)) -> and₂(eqt₂(E1, E2), and₂(eqs₂(S1, S2), eqc₂(CS1, CS2)))
push₃(E1, E2, nocalls) -> calls₃(E1, stack₂(E2, empty), nocalls)
push₃(E1, E2, calls₃(E3, S1, CS1)) -> push1₆(E1, E2, E3, S1, CS1, eqt₂(E1, E3))
push1₆(E1, E2, E3, S1, CS1, T) -> calls₃(E3, pushs₂(E2, S1), CS1)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

RECORD_UPDATES₃(Record, Name, cons₂(tuple₂(Field, tuplenil₁(NewF)), Fields)) -> RECORD_UPDATES₃(record_update₄(Record, Name, Field, NewF), Name, Fields)

The TRS R consists of the following rules:

or₂(T, T) -> T
or₂(F, T) -> T
or₂(T, F) -> T
or₂(F, F) -> F
and₂(T, B) -> B
and₂(B, T) -> B
and₂(F, B) -> F
and₂(B, F) -> F
imp₂(T, B) -> B
imp₂(F, B) -> T
not₁(T) -> F
not₁(F) -> T
if₃(T, B1, B2) -> B1
if₃(F, B1, B2) -> B2
eq₂(T, T) -> T
eq₂(F, F) -> T
eq₂(T, F) -> F
eq₂(F, T) -> F
eqt₂(nil, undefined) -> F
eqt₂(nil, pid₁(N2)) -> F
eqt₂(nil, int₁(N2)) -> F
eqt₂(nil, cons₂(H2, T2)) -> F
eqt₂(nil, tuple₂(H2, T2)) -> F
eqt₂(nil, tuplenil₁(H2)) -> F
eqt₂(a, nil) -> F
eqt₂(a, a) -> T
eqt₂(a, excl) -> F
eqt₂(a, false) -> F
eqt₂(a, lock) -> F
eqt₂(a, locker) -> F
eqt₂(a, mcrlrecord) -> F
eqt₂(a, ok) -> F
eqt₂(a, pending) -> F
eqt₂(a, release) -> F
eqt₂(a, request) -> F
eqt₂(a, resource) -> F
eqt₂(a, tag) -> F
eqt₂(a, true) -> F
eqt₂(a, undefined) -> F
eqt₂(a, pid₁(N2)) -> F
eqt₂(a, int₁(N2)) -> F
eqt₂(a, cons₂(H2, T2)) -> F
eqt₂(a, tuple₂(H2, T2)) -> F
eqt₂(a, tuplenil₁(H2)) -> F
eqt₂(excl, nil) -> F
eqt₂(excl, a) -> F
eqt₂(excl, excl) -> T
eqt₂(excl, false) -> F
eqt₂(excl, lock) -> F
eqt₂(excl, locker) -> F
eqt₂(excl, mcrlrecord) -> F
eqt₂(excl, ok) -> F
eqt₂(excl, pending) -> F
eqt₂(excl, release) -> F
eqt₂(excl, request) -> F
eqt₂(excl, resource) -> F
eqt₂(excl, tag) -> F
eqt₂(excl, true) -> F
eqt₂(excl, undefined) -> F
eqt₂(excl, pid₁(N2)) -> F
eqt₂(excl, eqt₂(false, int₁(N2))) -> F
eqt₂(false, cons₂(H2, T2)) -> F
eqt₂(false, tuple₂(H2, T2)) -> F
eqt₂(false, tuplenil₁(H2)) -> F
eqt₂(lock, nil) -> F
eqt₂(lock, a) -> F
eqt₂(lock, excl) -> F
eqt₂(lock, false) -> F
eqt₂(lock, lock) -> T
eqt₂(lock, locker) -> F
eqt₂(lock, mcrlrecord) -> F
eqt₂(lock, ok) -> F
eqt₂(lock, pending) -> F
eqt₂(lock, release) -> F
eqt₂(lock, request) -> F
eqt₂(lock, resource) -> F
eqt₂(lock, tag) -> F
eqt₂(lock, true) -> F
eqt₂(lock, undefined) -> F
eqt₂(lock, pid₁(N2)) -> F
eqt₂(lock, int₁(N2)) -> F
eqt₂(lock, cons₂(H2, T2)) -> F
eqt₂(lock, tuple₂(H2, T2)) -> F
eqt₂(lock, tuplenil₁(H2)) -> F
eqt₂(locker, nil) -> F
eqt₂(locker, a) -> F
eqt₂(locker, excl) -> F
eqt₂(locker, false) -> F
eqt₂(locker, lock) -> F
eqt₂(locker, locker) -> T
eqt₂(locker, mcrlrecord) -> F
eqt₂(locker, ok) -> F
eqt₂(locker, pending) -> F
eqt₂(locker, release) -> F
eqt₂(locker, request) -> F
eqt₂(locker, resource) -> F
eqt₂(locker, tag) -> F
eqt₂(locker, true) -> F
eqt₂(locker, undefined) -> F
eqt₂(locker, pid₁(N2)) -> F
eqt₂(locker, int₁(N2)) -> F
eqt₂(locker, cons₂(H2, T2)) -> F
eqt₂(locker, tuple₂(H2, T2)) -> F
eqt₂(locker, tuplenil₁(H2)) -> F
eqt₂(mcrlrecord, nil) -> F
eqt₂(mcrlrecord, a) -> F
eqt₂(mcrlrecord, excl) -> F
eqt₂(mcrlrecord, false) -> F
eqt₂(mcrlrecord, lock) -> F
eqt₂(mcrlrecord, locker) -> F
eqt₂(mcrlrecord, mcrlrecord) -> T
eqt₂(mcrlrecord, ok) -> F
eqt₂(mcrlrecord, pending) -> F
eqt₂(mcrlrecord, release) -> F
eqt₂(mcrlrecord, request) -> F
eqt₂(mcrlrecord, resource) -> F
eqt₂(ok, resource) -> F
eqt₂(ok, tag) -> F
eqt₂(ok, true) -> F
eqt₂(ok, undefined) -> F
eqt₂(ok, pid₁(N2)) -> F
eqt₂(ok, int₁(N2)) -> F
eqt₂(ok, cons₂(H2, T2)) -> F
eqt₂(ok, tuple₂(H2, T2)) -> F
eqt₂(ok, tuplenil₁(H2)) -> F
eqt₂(pending, nil) -> F
eqt₂(pending, a) -> F
eqt₂(pending, excl) -> F
eqt₂(pending, false) -> F
eqt₂(pending, lock) -> F
eqt₂(pending, locker) -> F
eqt₂(pending, mcrlrecord) -> F
eqt₂(pending, ok) -> F
eqt₂(pending, pending) -> T
eqt₂(pending, release) -> F
eqt₂(pending, request) -> F
eqt₂(pending, resource) -> F
eqt₂(pending, tag) -> F
eqt₂(pending, true) -> F
eqt₂(pending, undefined) -> F
eqt₂(pending, pid₁(N2)) -> F
eqt₂(pending, int₁(N2)) -> F
eqt₂(pending, cons₂(H2, T2)) -> F
eqt₂(pending, tuple₂(H2, T2)) -> F
eqt₂(pending, tuplenil₁(H2)) -> F
eqt₂(release, nil) -> F
eqt₂(release, a) -> F
eqt₂(release, excl) -> F
eqt₂(release, false) -> F
eqt₂(release, lock) -> F
eqt₂(release, locker) -> F
eqt₂(release, mcrlrecord) -> F
eqt₂(release, ok) -> F
eqt₂(request, mcrlrecord) -> F
eqt₂(request, ok) -> F
eqt₂(request, pending) -> F
eqt₂(request, release) -> F
eqt₂(request, request) -> T
eqt₂(request, resource) -> F
eqt₂(request, tag) -> F
eqt₂(request, true) -> F
eqt₂(request, undefined) -> F
eqt₂(request, pid₁(N2)) -> F
eqt₂(request, int₁(N2)) -> F
eqt₂(request, cons₂(H2, T2)) -> F
eqt₂(request, tuple₂(H2, T2)) -> F
eqt₂(request, tuplenil₁(H2)) -> F
eqt₂(resource, nil) -> F
eqt₂(resource, a) -> F
eqt₂(resource, excl) -> F
eqt₂(resource, false) -> F
eqt₂(resource, lock) -> F
eqt₂(resource, locker) -> F
eqt₂(resource, mcrlrecord) -> F
eqt₂(resource, ok) -> F
eqt₂(resource, pending) -> F
eqt₂(resource, release) -> F
eqt₂(resource, request) -> F
eqt₂(resource, resource) -> T
eqt₂(resource, tag) -> F
eqt₂(resource, true) -> F
eqt₂(resource, undefined) -> F
eqt₂(resource, pid₁(N2)) -> F
eqt₂(resource, int₁(N2)) -> F
eqt₂(resource, cons₂(H2, T2)) -> F
eqt₂(resource, tuple₂(H2, T2)) -> F
eqt₂(resource, tuplenil₁(H2)) -> F
eqt₂(tag, nil) -> F
eqt₂(tag, a) -> F
eqt₂(tag, excl) -> F
eqt₂(tag, false) -> F
eqt₂(tag, lock) -> F
eqt₂(tag, locker) -> F
eqt₂(tag, mcrlrecord) -> F
eqt₂(tag, ok) -> F
eqt₂(tag, pending) -> F
eqt₂(tag, release) -> F
eqt₂(tag, request) -> F
eqt₂(tag, resource) -> F
eqt₂(tag, tag) -> T
eqt₂(tag, true) -> F
eqt₂(tag, undefined) -> F
eqt₂(tag, pid₁(N2)) -> F
eqt₂(tag, int₁(N2)) -> F
eqt₂(tag, cons₂(H2, T2)) -> F
eqt₂(tag, tuple₂(H2, T2)) -> F
eqt₂(tag, tuplenil₁(H2)) -> F
eqt₂(true, nil) -> F
eqt₂(true, a) -> F
eqt₂(true, excl) -> F
eqt₂(true, false) -> F
eqt₂(true, lock) -> F
eqt₂(true, locker) -> F
eqt₂(true, mcrlrecord) -> F
eqt₂(true, ok) -> F
eqt₂(true, pending) -> F
eqt₂(true, release) -> F
eqt₂(true, request) -> F
eqt₂(true, resource) -> F
eqt₂(true, tag) -> F
eqt₂(true, true) -> T
eqt₂(true, undefined) -> F
eqt₂(true, pid₁(N2)) -> F
eqt₂(true, int₁(N2)) -> F
eqt₂(true, cons₂(H2, T2)) -> F
eqt₂(true, tuple₂(H2, T2)) -> F
eqt₂(true, tuplenil₁(H2)) -> F
eqt₂(undefined, nil) -> F
eqt₂(undefined, a) -> F
eqt₂(undefined, tuplenil₁(H2)) -> F
eqt₂(pid₁(N1), nil) -> F
eqt₂(pid₁(N1), a) -> F
eqt₂(pid₁(N1), excl) -> F
eqt₂(pid₁(N1), false) -> F
eqt₂(pid₁(N1), lock) -> F
eqt₂(pid₁(N1), locker) -> F
eqt₂(pid₁(N1), mcrlrecord) -> F
eqt₂(pid₁(N1), ok) -> F
eqt₂(pid₁(N1), pending) -> F
eqt₂(pid₁(N1), release) -> F
eqt₂(pid₁(N1), request) -> F
eqt₂(pid₁(N1), resource) -> F
eqt₂(pid₁(N1), tag) -> F
eqt₂(pid₁(N1), true) -> F
eqt₂(pid₁(N1), undefined) -> F
eqt₂(pid₁(N1), pid₁(N2)) -> eqt₂(N1, N2)
eqt₂(pid₁(N1), int₁(N2)) -> F
eqt₂(pid₁(N1), cons₂(H2, T2)) -> F
eqt₂(pid₁(N1), tuple₂(H2, T2)) -> F
eqt₂(pid₁(N1), tuplenil₁(H2)) -> F
eqt₂(int₁(N1), nil) -> F
eqt₂(int₁(N1), a) -> F
eqt₂(int₁(N1), excl) -> F
eqt₂(int₁(N1), false) -> F
eqt₂(int₁(N1), lock) -> F
eqt₂(int₁(N1), locker) -> F
eqt₂(int₁(N1), mcrlrecord) -> F
eqt₂(int₁(N1), ok) -> F
eqt₂(int₁(N1), pending) -> F
eqt₂(int₁(N1), release) -> F
eqt₂(int₁(N1), request) -> F
eqt₂(int₁(N1), resource) -> F
eqt₂(int₁(N1), tag) -> F
eqt₂(int₁(N1), true) -> F
eqt₂(int₁(N1), undefined) -> F
eqt₂(cons₂(H1, T1), resource) -> F
eqt₂(cons₂(H1, T1), tag) -> F
eqt₂(cons₂(H1, T1), true) -> F
eqt₂(cons₂(H1, T1), undefined) -> F
eqt₂(cons₂(H1, T1), pid₁(N2)) -> F
eqt₂(cons₂(H1, T1), int₁(N2)) -> F
eqt₂(cons₂(H1, T1), cons₂(H2, T2)) -> and₂(eqt₂(H1, H2), eqt₂(T1, T2))
eqt₂(cons₂(H1, T1), tuple₂(H2, T2)) -> F
eqt₂(cons₂(H1, T1), tuplenil₁(H2)) -> F
eqt₂(tuple₂(H1, T1), nil) -> F
eqt₂(tuple₂(H1, T1), a) -> F
eqt₂(tuple₂(H1, T1), excl) -> F
eqt₂(tuple₂(H1, T1), false) -> F
eqt₂(tuple₂(H1, T1), lock) -> F
eqt₂(tuple₂(H1, T1), locker) -> F
eqt₂(tuple₂(H1, T1), mcrlrecord) -> F
eqt₂(tuple₂(H1, T1), ok) -> F
eqt₂(tuple₂(H1, T1), pending) -> F
eqt₂(tuple₂(H1, T1), release) -> F
eqt₂(tuple₂(H1, T1), request) -> F
eqt₂(tuple₂(H1, T1), resource) -> F
eqt₂(tuple₂(H1, T1), tag) -> F
eqt₂(tuple₂(H1, T1), true) -> F
eqt₂(tuple₂(H1, T1), undefined) -> F
eqt₂(tuple₂(H1, T1), pid₁(N2)) -> F
eqt₂(tuple₂(H1, T1), int₁(N2)) -> F
eqt₂(tuple₂(H1, T1), cons₂(H2, T2)) -> F
eqt₂(tuple₂(H1, T1), tuple₂(H2, T2)) -> and₂(eqt₂(H1, H2), eqt₂(T1, T2))
eqt₂(tuple₂(H1, T1), tuplenil₁(H2)) -> F
eqt₂(tuplenil₁(H1), nil) -> F
eqt₂(tuplenil₁(H1), a) -> F
eqt₂(tuplenil₁(H1), excl) -> F
eqt₂(tuplenil₁(H1), false) -> F
eqt₂(tuplenil₁(H1), lock) -> F
eqt₂(tuplenil₁(H1), locker) -> F
eqt₂(tuplenil₁(H1), mcrlrecord) -> F
eqt₂(tuplenil₁(H1), ok) -> F
eqt₂(tuplenil₁(H1), pending) -> F
eqt₂(tuplenil₁(H1), release) -> F
eqt₂(tuplenil₁(H1), request) -> F
eqt₂(tuplenil₁(H1), resource) -> F
eqt₂(tuplenil₁(H1), tag) -> F
eqt₂(tuplenil₁(H1), true) -> F
eqt₂(tuplenil₁(H1), undefined) -> F
eqt₂(tuplenil₁(H1), pid₁(N2)) -> F
eqt₂(tuplenil₁(H1), int₁(N2)) -> F
eqt₂(tuplenil₁(H1), cons₂(H2, T2)) -> F
eqt₂(tuplenil₁(H1), tuple₂(H2, T2)) -> F
eqt₂(tuplenil₁(H1), tuplenil₁(H2)) -> eqt₂(H1, H2)
element₂(int₁(s₁(0)), tuplenil₁(T1)) -> T1
element₂(int₁(s₁(0)), tuple₂(T1, T2)) -> T1
element₂(int₁(s₁(s₁(N1))), tuple₂(T1, T2)) -> element₂(int₁(s₁(N1)), T2)
record_new₁(lock) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(undefined, tuple₂(nil, tuplenil₁(nil)))))
record_extract₃(tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2))))), lock, resource) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2)))))
record_update₄(tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2))))), lock, pending, NewF) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(NewF)))))
record_updates₃(Record, Name, nil) -> Record
record_updates₃(Record, Name, cons₂(tuple₂(Field, tuplenil₁(NewF)), Fields)) -> record_updates₃(record_update₄(Record, Name, Field, NewF), Name, Fields)
locker2_map_promote_pending₂(nil, Pending) -> nil
locker2_map_promote_pending₂(cons₂(Lock, Locks), Pending) -> cons₂(locker2_promote_pending₂(Lock, Pending), locker2_map_promote_pending₂(Locks, Pending))
locker2_map_claim_lock₃(nil, Resources, Client) -> nil
locker2_map_claim_lock₃(cons₂(Lock, Locks), Resources, Client) -> cons₂(locker2_claim_lock₃(Lock, Resources, Client), locker2_map_claim_lock₃(Locks, Resources, Client))
locker2_map_add_pending₃(nil, Resources, Client) -> nil
locker2_promote_pending₂(Lock, Client) -> case0₃(Client, Lock, record_extract₃(Lock, lock, pending))
case0₃(Client, Lock, cons₂(Client, Pendings)) -> record_updates₃(Lock, lock, cons₂(tuple₂(excl, tuplenil₁(Client)), cons₂(tuple₂(pending, tuplenil₁(Pendings)), nil)))
case0₃(Client, Lock, MCRLFree0) -> Lock
locker2_remove_pending₂(Lock, Client) -> record_updates₃(Lock, lock, cons₂(tuple₂(pending, tuplenil₁(subtract₂(record_extract₃(Lock, lock, pending), cons₂(Client, nil)))), nil))
locker2_add_pending₃(Lock, Resources, Client) -> case1₄(Client, Resources, Lock, member₂(record_extract₃(Lock, lock, resource), Resources))
case1₄(Client, Resources, Lock, true) -> record_updates₃(Lock, lock, cons₂(tuple₂(pending, tuplenil₁(append₂(record_extract₃(Lock, lock, pending), cons₂(Client, nil)))), nil))
case1₄(Client, Resources, Lock, false) -> Lock
locker2_release_lock₂(Lock, Client) -> case2₃(Client, Lock, gen_modtageq₂(Client, record_extract₃(Lock, lock, excl)))
case2₃(Client, Lock, true) -> record_updates₃(Lock, lock, cons₂(tuple₂(excllock, excl), nil))
case4₃(Client, Lock, MCRLFree1) -> false
locker2_obtainables₂(nil, Client) -> true
locker2_obtainables₂(cons₂(Lock, Locks), Client) -> case5₄(Client, Locks, Lock, member₂(Client, record_extract₃(Lock, lock, pending)))
case5₄(Client, Locks, Lock, true) -> andt₂(locker2_obtainable₂(Lock, Client), locker2_obtainables₂(Locks, Client))
case5₄(Client, Locks, Lock, false) -> locker2_obtainables₂(Locks, Client)
locker2_check_available₂(Resource, nil) -> false
locker2_check_available₂(Resource, cons₂(Lock, Locks)) -> case6₄(Locks, Lock, Resource, equal₂(Resource, record_extract₃(Lock, lock, resource)))
case6₄(Locks, Lock, Resource, true) -> andt₂(equal₂(record_extract₃(Lock, lock, excl), nil), equal₂(record_extract₃(Lock, lock, pending), nil))
case6₄(Locks, Lock, Resource, false) -> locker2_check_available₂(Resource, Locks)
locker2_check_availables₂(nil, Locks) -> true
locker2_check_availables₂(cons₂(Resource, Resources), Locks) -> andt₂(locker2_check_available₂(Resource, Locks), locker2_check_availables₂(Resources, Locks))
locker2_adduniq₂(nil, List) -> List
append₂(cons₂(Head, Tail), List) -> cons₂(Head, append₂(Tail, List))
subtract₂(List, nil) -> List
subtract₂(List, cons₂(Head, Tail)) -> subtract₂(delete₂(Head, List), Tail)
delete₂(E, nil) -> nil
delete₂(E, cons₂(Head, Tail)) -> case8₄(Tail, Head, E, equal₂(E, Head))
case8₄(Tail, Head, E, true) -> Tail
case8₄(Tail, Head, E, false) -> cons₂(Head, delete₂(E, Tail))
gen_tag₁(Pid) -> tuple₂(Pid, tuplenil₁(tag))
gen_modtageq₂(Client1, Client2) -> equal₂(Client1, Client2)
member₂(E, nil) -> false
member₂(E, cons₂(Head, Tail)) -> case9₄(Tail, Head, E, equal₂(E, Head))
case9₄(Tail, Head, E, true) -> true
case9₄(Tail, Head, E, false) -> member₂(E, Tail)
eqs₂(empty, empty) -> T
eqs₂(empty, stack₂(E2, S2)) -> F
eqs₂(stack₂(E1, S1), empty) -> F
eqs₂(stack₂(E1, S1), stack₂(E2, S2)) -> and₂(eqt₂(E1, E2), eqs₂(S1, S2))
pushs₂(E1, S1) -> stack₂(E1, S1)
pops₁(stack₂(E1, S1)) -> S1
tops₁(stack₂(E1, S1)) -> E1
istops₂(E1, empty) -> F
istops₂(E1, stack₂(E2, S1)) -> eqt₂(E1, E2)
eqc₂(nocalls, nocalls) -> T
eqc₂(nocalls, calls₃(E2, S2, CS2)) -> F
eqc₂(calls₃(E1, S1, CS1), nocalls) -> F
eqc₂(calls₃(E1, S1, CS1), calls₃(E2, S2, CS2)) -> and₂(eqt₂(E1, E2), and₂(eqs₂(S1, S2), eqc₂(CS1, CS2)))
push₃(E1, E2, nocalls) -> calls₃(E1, stack₂(E2, empty), nocalls)
push₃(E1, E2, calls₃(E3, S1, CS1)) -> push1₆(E1, E2, E3, S1, CS1, eqt₂(E1, E3))
push1₆(E1, E2, E3, S1, CS1, T) -> calls₃(E3, pushs₂(E2, S1), CS1)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

RECORD_UPDATES₃(Record, Name, cons₂(tuple₂(Field, tuplenil₁(NewF)), Fields)) -> RECORD_UPDATES₃(record_update₄(Record, Name, Field, NewF), Name, Fields)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial Order [17,21] with Interpretation:

POL( tuple₂(x₁, x₂) ) = max{0, -1}

POL( tuplenil₁(x₁) ) = 1

POL( lock ) = 0

POL( mcrlrecord ) = 0

POL( RECORD_UPDATES₃(x₁, ..., x₃) ) = x₃

POL( record_update₄(x₁, ..., x₄) ) = max{0, x₄ - 1}

POL( cons₂(x₁, x₂) ) = x₂ + 1

POL( pending ) = 0

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

or₂(T, T) -> T
or₂(F, T) -> T
or₂(T, F) -> T
or₂(F, F) -> F
and₂(T, B) -> B
and₂(B, T) -> B
and₂(F, B) -> F
and₂(B, F) -> F
imp₂(T, B) -> B
imp₂(F, B) -> T
not₁(T) -> F
not₁(F) -> T
if₃(T, B1, B2) -> B1
if₃(F, B1, B2) -> B2
eq₂(T, T) -> T
eq₂(F, F) -> T
eq₂(T, F) -> F
eq₂(F, T) -> F
eqt₂(nil, undefined) -> F
eqt₂(nil, pid₁(N2)) -> F
eqt₂(nil, int₁(N2)) -> F
eqt₂(nil, cons₂(H2, T2)) -> F
eqt₂(nil, tuple₂(H2, T2)) -> F
eqt₂(nil, tuplenil₁(H2)) -> F
eqt₂(a, nil) -> F
eqt₂(a, a) -> T
eqt₂(a, excl) -> F
eqt₂(a, false) -> F
eqt₂(a, lock) -> F
eqt₂(a, locker) -> F
eqt₂(a, mcrlrecord) -> F
eqt₂(a, ok) -> F
eqt₂(a, pending) -> F
eqt₂(a, release) -> F
eqt₂(a, request) -> F
eqt₂(a, resource) -> F
eqt₂(a, tag) -> F
eqt₂(a, true) -> F
eqt₂(a, undefined) -> F
eqt₂(a, pid₁(N2)) -> F
eqt₂(a, int₁(N2)) -> F
eqt₂(a, cons₂(H2, T2)) -> F
eqt₂(a, tuple₂(H2, T2)) -> F
eqt₂(a, tuplenil₁(H2)) -> F
eqt₂(excl, nil) -> F
eqt₂(excl, a) -> F
eqt₂(excl, excl) -> T
eqt₂(excl, false) -> F
eqt₂(excl, lock) -> F
eqt₂(excl, locker) -> F
eqt₂(excl, mcrlrecord) -> F
eqt₂(excl, ok) -> F
eqt₂(excl, pending) -> F
eqt₂(excl, release) -> F
eqt₂(excl, request) -> F
eqt₂(excl, resource) -> F
eqt₂(excl, tag) -> F
eqt₂(excl, true) -> F
eqt₂(excl, undefined) -> F
eqt₂(excl, pid₁(N2)) -> F
eqt₂(excl, eqt₂(false, int₁(N2))) -> F
eqt₂(false, cons₂(H2, T2)) -> F
eqt₂(false, tuple₂(H2, T2)) -> F
eqt₂(false, tuplenil₁(H2)) -> F
eqt₂(lock, nil) -> F
eqt₂(lock, a) -> F
eqt₂(lock, excl) -> F
eqt₂(lock, false) -> F
eqt₂(lock, lock) -> T
eqt₂(lock, locker) -> F
eqt₂(lock, mcrlrecord) -> F
eqt₂(lock, ok) -> F
eqt₂(lock, pending) -> F
eqt₂(lock, release) -> F
eqt₂(lock, request) -> F
eqt₂(lock, resource) -> F
eqt₂(lock, tag) -> F
eqt₂(lock, true) -> F
eqt₂(lock, undefined) -> F
eqt₂(lock, pid₁(N2)) -> F
eqt₂(lock, int₁(N2)) -> F
eqt₂(lock, cons₂(H2, T2)) -> F
eqt₂(lock, tuple₂(H2, T2)) -> F
eqt₂(lock, tuplenil₁(H2)) -> F
eqt₂(locker, nil) -> F
eqt₂(locker, a) -> F
eqt₂(locker, excl) -> F
eqt₂(locker, false) -> F
eqt₂(locker, lock) -> F
eqt₂(locker, locker) -> T
eqt₂(locker, mcrlrecord) -> F
eqt₂(locker, ok) -> F
eqt₂(locker, pending) -> F
eqt₂(locker, release) -> F
eqt₂(locker, request) -> F
eqt₂(locker, resource) -> F
eqt₂(locker, tag) -> F
eqt₂(locker, true) -> F
eqt₂(locker, undefined) -> F
eqt₂(locker, pid₁(N2)) -> F
eqt₂(locker, int₁(N2)) -> F
eqt₂(locker, cons₂(H2, T2)) -> F
eqt₂(locker, tuple₂(H2, T2)) -> F
eqt₂(locker, tuplenil₁(H2)) -> F
eqt₂(mcrlrecord, nil) -> F
eqt₂(mcrlrecord, a) -> F
eqt₂(mcrlrecord, excl) -> F
eqt₂(mcrlrecord, false) -> F
eqt₂(mcrlrecord, lock) -> F
eqt₂(mcrlrecord, locker) -> F
eqt₂(mcrlrecord, mcrlrecord) -> T
eqt₂(mcrlrecord, ok) -> F
eqt₂(mcrlrecord, pending) -> F
eqt₂(mcrlrecord, release) -> F
eqt₂(mcrlrecord, request) -> F
eqt₂(mcrlrecord, resource) -> F
eqt₂(ok, resource) -> F
eqt₂(ok, tag) -> F
eqt₂(ok, true) -> F
eqt₂(ok, undefined) -> F
eqt₂(ok, pid₁(N2)) -> F
eqt₂(ok, int₁(N2)) -> F
eqt₂(ok, cons₂(H2, T2)) -> F
eqt₂(ok, tuple₂(H2, T2)) -> F
eqt₂(ok, tuplenil₁(H2)) -> F
eqt₂(pending, nil) -> F
eqt₂(pending, a) -> F
eqt₂(pending, excl) -> F
eqt₂(pending, false) -> F
eqt₂(pending, lock) -> F
eqt₂(pending, locker) -> F
eqt₂(pending, mcrlrecord) -> F
eqt₂(pending, ok) -> F
eqt₂(pending, pending) -> T
eqt₂(pending, release) -> F
eqt₂(pending, request) -> F
eqt₂(pending, resource) -> F
eqt₂(pending, tag) -> F
eqt₂(pending, true) -> F
eqt₂(pending, undefined) -> F
eqt₂(pending, pid₁(N2)) -> F
eqt₂(pending, int₁(N2)) -> F
eqt₂(pending, cons₂(H2, T2)) -> F
eqt₂(pending, tuple₂(H2, T2)) -> F
eqt₂(pending, tuplenil₁(H2)) -> F
eqt₂(release, nil) -> F
eqt₂(release, a) -> F
eqt₂(release, excl) -> F
eqt₂(release, false) -> F
eqt₂(release, lock) -> F
eqt₂(release, locker) -> F
eqt₂(release, mcrlrecord) -> F
eqt₂(release, ok) -> F
eqt₂(request, mcrlrecord) -> F
eqt₂(request, ok) -> F
eqt₂(request, pending) -> F
eqt₂(request, release) -> F
eqt₂(request, request) -> T
eqt₂(request, resource) -> F
eqt₂(request, tag) -> F
eqt₂(request, true) -> F
eqt₂(request, undefined) -> F
eqt₂(request, pid₁(N2)) -> F
eqt₂(request, int₁(N2)) -> F
eqt₂(request, cons₂(H2, T2)) -> F
eqt₂(request, tuple₂(H2, T2)) -> F
eqt₂(request, tuplenil₁(H2)) -> F
eqt₂(resource, nil) -> F
eqt₂(resource, a) -> F
eqt₂(resource, excl) -> F
eqt₂(resource, false) -> F
eqt₂(resource, lock) -> F
eqt₂(resource, locker) -> F
eqt₂(resource, mcrlrecord) -> F
eqt₂(resource, ok) -> F
eqt₂(resource, pending) -> F
eqt₂(resource, release) -> F
eqt₂(resource, request) -> F
eqt₂(resource, resource) -> T
eqt₂(resource, tag) -> F
eqt₂(resource, true) -> F
eqt₂(resource, undefined) -> F
eqt₂(resource, pid₁(N2)) -> F
eqt₂(resource, int₁(N2)) -> F
eqt₂(resource, cons₂(H2, T2)) -> F
eqt₂(resource, tuple₂(H2, T2)) -> F
eqt₂(resource, tuplenil₁(H2)) -> F
eqt₂(tag, nil) -> F
eqt₂(tag, a) -> F
eqt₂(tag, excl) -> F
eqt₂(tag, false) -> F
eqt₂(tag, lock) -> F
eqt₂(tag, locker) -> F
eqt₂(tag, mcrlrecord) -> F
eqt₂(tag, ok) -> F
eqt₂(tag, pending) -> F
eqt₂(tag, release) -> F
eqt₂(tag, request) -> F
eqt₂(tag, resource) -> F
eqt₂(tag, tag) -> T
eqt₂(tag, true) -> F
eqt₂(tag, undefined) -> F
eqt₂(tag, pid₁(N2)) -> F
eqt₂(tag, int₁(N2)) -> F
eqt₂(tag, cons₂(H2, T2)) -> F
eqt₂(tag, tuple₂(H2, T2)) -> F
eqt₂(tag, tuplenil₁(H2)) -> F
eqt₂(true, nil) -> F
eqt₂(true, a) -> F
eqt₂(true, excl) -> F
eqt₂(true, false) -> F
eqt₂(true, lock) -> F
eqt₂(true, locker) -> F
eqt₂(true, mcrlrecord) -> F
eqt₂(true, ok) -> F
eqt₂(true, pending) -> F
eqt₂(true, release) -> F
eqt₂(true, request) -> F
eqt₂(true, resource) -> F
eqt₂(true, tag) -> F
eqt₂(true, true) -> T
eqt₂(true, undefined) -> F
eqt₂(true, pid₁(N2)) -> F
eqt₂(true, int₁(N2)) -> F
eqt₂(true, cons₂(H2, T2)) -> F
eqt₂(true, tuple₂(H2, T2)) -> F
eqt₂(true, tuplenil₁(H2)) -> F
eqt₂(undefined, nil) -> F
eqt₂(undefined, a) -> F
eqt₂(undefined, tuplenil₁(H2)) -> F
eqt₂(pid₁(N1), nil) -> F
eqt₂(pid₁(N1), a) -> F
eqt₂(pid₁(N1), excl) -> F
eqt₂(pid₁(N1), false) -> F
eqt₂(pid₁(N1), lock) -> F
eqt₂(pid₁(N1), locker) -> F
eqt₂(pid₁(N1), mcrlrecord) -> F
eqt₂(pid₁(N1), ok) -> F
eqt₂(pid₁(N1), pending) -> F
eqt₂(pid₁(N1), release) -> F
eqt₂(pid₁(N1), request) -> F
eqt₂(pid₁(N1), resource) -> F
eqt₂(pid₁(N1), tag) -> F
eqt₂(pid₁(N1), true) -> F
eqt₂(pid₁(N1), undefined) -> F
eqt₂(pid₁(N1), pid₁(N2)) -> eqt₂(N1, N2)
eqt₂(pid₁(N1), int₁(N2)) -> F
eqt₂(pid₁(N1), cons₂(H2, T2)) -> F
eqt₂(pid₁(N1), tuple₂(H2, T2)) -> F
eqt₂(pid₁(N1), tuplenil₁(H2)) -> F
eqt₂(int₁(N1), nil) -> F
eqt₂(int₁(N1), a) -> F
eqt₂(int₁(N1), excl) -> F
eqt₂(int₁(N1), false) -> F
eqt₂(int₁(N1), lock) -> F
eqt₂(int₁(N1), locker) -> F
eqt₂(int₁(N1), mcrlrecord) -> F
eqt₂(int₁(N1), ok) -> F
eqt₂(int₁(N1), pending) -> F
eqt₂(int₁(N1), release) -> F
eqt₂(int₁(N1), request) -> F
eqt₂(int₁(N1), resource) -> F
eqt₂(int₁(N1), tag) -> F
eqt₂(int₁(N1), true) -> F
eqt₂(int₁(N1), undefined) -> F
eqt₂(cons₂(H1, T1), resource) -> F
eqt₂(cons₂(H1, T1), tag) -> F
eqt₂(cons₂(H1, T1), true) -> F
eqt₂(cons₂(H1, T1), undefined) -> F
eqt₂(cons₂(H1, T1), pid₁(N2)) -> F
eqt₂(cons₂(H1, T1), int₁(N2)) -> F
eqt₂(cons₂(H1, T1), cons₂(H2, T2)) -> and₂(eqt₂(H1, H2), eqt₂(T1, T2))
eqt₂(cons₂(H1, T1), tuple₂(H2, T2)) -> F
eqt₂(cons₂(H1, T1), tuplenil₁(H2)) -> F
eqt₂(tuple₂(H1, T1), nil) -> F
eqt₂(tuple₂(H1, T1), a) -> F
eqt₂(tuple₂(H1, T1), excl) -> F
eqt₂(tuple₂(H1, T1), false) -> F
eqt₂(tuple₂(H1, T1), lock) -> F
eqt₂(tuple₂(H1, T1), locker) -> F
eqt₂(tuple₂(H1, T1), mcrlrecord) -> F
eqt₂(tuple₂(H1, T1), ok) -> F
eqt₂(tuple₂(H1, T1), pending) -> F
eqt₂(tuple₂(H1, T1), release) -> F
eqt₂(tuple₂(H1, T1), request) -> F
eqt₂(tuple₂(H1, T1), resource) -> F
eqt₂(tuple₂(H1, T1), tag) -> F
eqt₂(tuple₂(H1, T1), true) -> F
eqt₂(tuple₂(H1, T1), undefined) -> F
eqt₂(tuple₂(H1, T1), pid₁(N2)) -> F
eqt₂(tuple₂(H1, T1), int₁(N2)) -> F
eqt₂(tuple₂(H1, T1), cons₂(H2, T2)) -> F
eqt₂(tuple₂(H1, T1), tuple₂(H2, T2)) -> and₂(eqt₂(H1, H2), eqt₂(T1, T2))
eqt₂(tuple₂(H1, T1), tuplenil₁(H2)) -> F
eqt₂(tuplenil₁(H1), nil) -> F
eqt₂(tuplenil₁(H1), a) -> F
eqt₂(tuplenil₁(H1), excl) -> F
eqt₂(tuplenil₁(H1), false) -> F
eqt₂(tuplenil₁(H1), lock) -> F
eqt₂(tuplenil₁(H1), locker) -> F
eqt₂(tuplenil₁(H1), mcrlrecord) -> F
eqt₂(tuplenil₁(H1), ok) -> F
eqt₂(tuplenil₁(H1), pending) -> F
eqt₂(tuplenil₁(H1), release) -> F
eqt₂(tuplenil₁(H1), request) -> F
eqt₂(tuplenil₁(H1), resource) -> F
eqt₂(tuplenil₁(H1), tag) -> F
eqt₂(tuplenil₁(H1), true) -> F
eqt₂(tuplenil₁(H1), undefined) -> F
eqt₂(tuplenil₁(H1), pid₁(N2)) -> F
eqt₂(tuplenil₁(H1), int₁(N2)) -> F
eqt₂(tuplenil₁(H1), cons₂(H2, T2)) -> F
eqt₂(tuplenil₁(H1), tuple₂(H2, T2)) -> F
eqt₂(tuplenil₁(H1), tuplenil₁(H2)) -> eqt₂(H1, H2)
element₂(int₁(s₁(0)), tuplenil₁(T1)) -> T1
element₂(int₁(s₁(0)), tuple₂(T1, T2)) -> T1
element₂(int₁(s₁(s₁(N1))), tuple₂(T1, T2)) -> element₂(int₁(s₁(N1)), T2)
record_new₁(lock) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(undefined, tuple₂(nil, tuplenil₁(nil)))))
record_extract₃(tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2))))), lock, resource) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2)))))
record_update₄(tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2))))), lock, pending, NewF) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(NewF)))))
record_updates₃(Record, Name, nil) -> Record
record_updates₃(Record, Name, cons₂(tuple₂(Field, tuplenil₁(NewF)), Fields)) -> record_updates₃(record_update₄(Record, Name, Field, NewF), Name, Fields)
locker2_map_promote_pending₂(nil, Pending) -> nil
locker2_map_promote_pending₂(cons₂(Lock, Locks), Pending) -> cons₂(locker2_promote_pending₂(Lock, Pending), locker2_map_promote_pending₂(Locks, Pending))
locker2_map_claim_lock₃(nil, Resources, Client) -> nil
locker2_map_claim_lock₃(cons₂(Lock, Locks), Resources, Client) -> cons₂(locker2_claim_lock₃(Lock, Resources, Client), locker2_map_claim_lock₃(Locks, Resources, Client))
locker2_map_add_pending₃(nil, Resources, Client) -> nil
locker2_promote_pending₂(Lock, Client) -> case0₃(Client, Lock, record_extract₃(Lock, lock, pending))
case0₃(Client, Lock, cons₂(Client, Pendings)) -> record_updates₃(Lock, lock, cons₂(tuple₂(excl, tuplenil₁(Client)), cons₂(tuple₂(pending, tuplenil₁(Pendings)), nil)))
case0₃(Client, Lock, MCRLFree0) -> Lock
locker2_remove_pending₂(Lock, Client) -> record_updates₃(Lock, lock, cons₂(tuple₂(pending, tuplenil₁(subtract₂(record_extract₃(Lock, lock, pending), cons₂(Client, nil)))), nil))
locker2_add_pending₃(Lock, Resources, Client) -> case1₄(Client, Resources, Lock, member₂(record_extract₃(Lock, lock, resource), Resources))
case1₄(Client, Resources, Lock, true) -> record_updates₃(Lock, lock, cons₂(tuple₂(pending, tuplenil₁(append₂(record_extract₃(Lock, lock, pending), cons₂(Client, nil)))), nil))
case1₄(Client, Resources, Lock, false) -> Lock
locker2_release_lock₂(Lock, Client) -> case2₃(Client, Lock, gen_modtageq₂(Client, record_extract₃(Lock, lock, excl)))
case2₃(Client, Lock, true) -> record_updates₃(Lock, lock, cons₂(tuple₂(excllock, excl), nil))
case4₃(Client, Lock, MCRLFree1) -> false
locker2_obtainables₂(nil, Client) -> true
locker2_obtainables₂(cons₂(Lock, Locks), Client) -> case5₄(Client, Locks, Lock, member₂(Client, record_extract₃(Lock, lock, pending)))
case5₄(Client, Locks, Lock, true) -> andt₂(locker2_obtainable₂(Lock, Client), locker2_obtainables₂(Locks, Client))
case5₄(Client, Locks, Lock, false) -> locker2_obtainables₂(Locks, Client)
locker2_check_available₂(Resource, nil) -> false
locker2_check_available₂(Resource, cons₂(Lock, Locks)) -> case6₄(Locks, Lock, Resource, equal₂(Resource, record_extract₃(Lock, lock, resource)))
case6₄(Locks, Lock, Resource, true) -> andt₂(equal₂(record_extract₃(Lock, lock, excl), nil), equal₂(record_extract₃(Lock, lock, pending), nil))
case6₄(Locks, Lock, Resource, false) -> locker2_check_available₂(Resource, Locks)
locker2_check_availables₂(nil, Locks) -> true
locker2_check_availables₂(cons₂(Resource, Resources), Locks) -> andt₂(locker2_check_available₂(Resource, Locks), locker2_check_availables₂(Resources, Locks))
locker2_adduniq₂(nil, List) -> List
append₂(cons₂(Head, Tail), List) -> cons₂(Head, append₂(Tail, List))
subtract₂(List, nil) -> List
subtract₂(List, cons₂(Head, Tail)) -> subtract₂(delete₂(Head, List), Tail)
delete₂(E, nil) -> nil
delete₂(E, cons₂(Head, Tail)) -> case8₄(Tail, Head, E, equal₂(E, Head))
case8₄(Tail, Head, E, true) -> Tail
case8₄(Tail, Head, E, false) -> cons₂(Head, delete₂(E, Tail))
gen_tag₁(Pid) -> tuple₂(Pid, tuplenil₁(tag))
gen_modtageq₂(Client1, Client2) -> equal₂(Client1, Client2)
member₂(E, nil) -> false
member₂(E, cons₂(Head, Tail)) -> case9₄(Tail, Head, E, equal₂(E, Head))
case9₄(Tail, Head, E, true) -> true
case9₄(Tail, Head, E, false) -> member₂(E, Tail)
eqs₂(empty, empty) -> T
eqs₂(empty, stack₂(E2, S2)) -> F
eqs₂(stack₂(E1, S1), empty) -> F
eqs₂(stack₂(E1, S1), stack₂(E2, S2)) -> and₂(eqt₂(E1, E2), eqs₂(S1, S2))
pushs₂(E1, S1) -> stack₂(E1, S1)
pops₁(stack₂(E1, S1)) -> S1
tops₁(stack₂(E1, S1)) -> E1
istops₂(E1, empty) -> F
istops₂(E1, stack₂(E2, S1)) -> eqt₂(E1, E2)
eqc₂(nocalls, nocalls) -> T
eqc₂(nocalls, calls₃(E2, S2, CS2)) -> F
eqc₂(calls₃(E1, S1, CS1), nocalls) -> F
eqc₂(calls₃(E1, S1, CS1), calls₃(E2, S2, CS2)) -> and₂(eqt₂(E1, E2), and₂(eqs₂(S1, S2), eqc₂(CS1, CS2)))
push₃(E1, E2, nocalls) -> calls₃(E1, stack₂(E2, empty), nocalls)
push₃(E1, E2, calls₃(E3, S1, CS1)) -> push1₆(E1, E2, E3, S1, CS1, eqt₂(E1, E3))
push1₆(E1, E2, E3, S1, CS1, T) -> calls₃(E3, pushs₂(E2, S1), CS1)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

LOCKER2_MAP_PROMOTE_PENDING₂(cons₂(Lock, Locks), Pending) -> LOCKER2_MAP_PROMOTE_PENDING₂(Locks, Pending)

The TRS R consists of the following rules:

or₂(T, T) -> T
or₂(F, T) -> T
or₂(T, F) -> T
or₂(F, F) -> F
and₂(T, B) -> B
and₂(B, T) -> B
and₂(F, B) -> F
and₂(B, F) -> F
imp₂(T, B) -> B
imp₂(F, B) -> T
not₁(T) -> F
not₁(F) -> T
if₃(T, B1, B2) -> B1
if₃(F, B1, B2) -> B2
eq₂(T, T) -> T
eq₂(F, F) -> T
eq₂(T, F) -> F
eq₂(F, T) -> F
eqt₂(nil, undefined) -> F
eqt₂(nil, pid₁(N2)) -> F
eqt₂(nil, int₁(N2)) -> F
eqt₂(nil, cons₂(H2, T2)) -> F
eqt₂(nil, tuple₂(H2, T2)) -> F
eqt₂(nil, tuplenil₁(H2)) -> F
eqt₂(a, nil) -> F
eqt₂(a, a) -> T
eqt₂(a, excl) -> F
eqt₂(a, false) -> F
eqt₂(a, lock) -> F
eqt₂(a, locker) -> F
eqt₂(a, mcrlrecord) -> F
eqt₂(a, ok) -> F
eqt₂(a, pending) -> F
eqt₂(a, release) -> F
eqt₂(a, request) -> F
eqt₂(a, resource) -> F
eqt₂(a, tag) -> F
eqt₂(a, true) -> F
eqt₂(a, undefined) -> F
eqt₂(a, pid₁(N2)) -> F
eqt₂(a, int₁(N2)) -> F
eqt₂(a, cons₂(H2, T2)) -> F
eqt₂(a, tuple₂(H2, T2)) -> F
eqt₂(a, tuplenil₁(H2)) -> F
eqt₂(excl, nil) -> F
eqt₂(excl, a) -> F
eqt₂(excl, excl) -> T
eqt₂(excl, false) -> F
eqt₂(excl, lock) -> F
eqt₂(excl, locker) -> F
eqt₂(excl, mcrlrecord) -> F
eqt₂(excl, ok) -> F
eqt₂(excl, pending) -> F
eqt₂(excl, release) -> F
eqt₂(excl, request) -> F
eqt₂(excl, resource) -> F
eqt₂(excl, tag) -> F
eqt₂(excl, true) -> F
eqt₂(excl, undefined) -> F
eqt₂(excl, pid₁(N2)) -> F
eqt₂(excl, eqt₂(false, int₁(N2))) -> F
eqt₂(false, cons₂(H2, T2)) -> F
eqt₂(false, tuple₂(H2, T2)) -> F
eqt₂(false, tuplenil₁(H2)) -> F
eqt₂(lock, nil) -> F
eqt₂(lock, a) -> F
eqt₂(lock, excl) -> F
eqt₂(lock, false) -> F
eqt₂(lock, lock) -> T
eqt₂(lock, locker) -> F
eqt₂(lock, mcrlrecord) -> F
eqt₂(lock, ok) -> F
eqt₂(lock, pending) -> F
eqt₂(lock, release) -> F
eqt₂(lock, request) -> F
eqt₂(lock, resource) -> F
eqt₂(lock, tag) -> F
eqt₂(lock, true) -> F
eqt₂(lock, undefined) -> F
eqt₂(lock, pid₁(N2)) -> F
eqt₂(lock, int₁(N2)) -> F
eqt₂(lock, cons₂(H2, T2)) -> F
eqt₂(lock, tuple₂(H2, T2)) -> F
eqt₂(lock, tuplenil₁(H2)) -> F
eqt₂(locker, nil) -> F
eqt₂(locker, a) -> F
eqt₂(locker, excl) -> F
eqt₂(locker, false) -> F
eqt₂(locker, lock) -> F
eqt₂(locker, locker) -> T
eqt₂(locker, mcrlrecord) -> F
eqt₂(locker, ok) -> F
eqt₂(locker, pending) -> F
eqt₂(locker, release) -> F
eqt₂(locker, request) -> F
eqt₂(locker, resource) -> F
eqt₂(locker, tag) -> F
eqt₂(locker, true) -> F
eqt₂(locker, undefined) -> F
eqt₂(locker, pid₁(N2)) -> F
eqt₂(locker, int₁(N2)) -> F
eqt₂(locker, cons₂(H2, T2)) -> F
eqt₂(locker, tuple₂(H2, T2)) -> F
eqt₂(locker, tuplenil₁(H2)) -> F
eqt₂(mcrlrecord, nil) -> F
eqt₂(mcrlrecord, a) -> F
eqt₂(mcrlrecord, excl) -> F
eqt₂(mcrlrecord, false) -> F
eqt₂(mcrlrecord, lock) -> F
eqt₂(mcrlrecord, locker) -> F
eqt₂(mcrlrecord, mcrlrecord) -> T
eqt₂(mcrlrecord, ok) -> F
eqt₂(mcrlrecord, pending) -> F
eqt₂(mcrlrecord, release) -> F
eqt₂(mcrlrecord, request) -> F
eqt₂(mcrlrecord, resource) -> F
eqt₂(ok, resource) -> F
eqt₂(ok, tag) -> F
eqt₂(ok, true) -> F
eqt₂(ok, undefined) -> F
eqt₂(ok, pid₁(N2)) -> F
eqt₂(ok, int₁(N2)) -> F
eqt₂(ok, cons₂(H2, T2)) -> F
eqt₂(ok, tuple₂(H2, T2)) -> F
eqt₂(ok, tuplenil₁(H2)) -> F
eqt₂(pending, nil) -> F
eqt₂(pending, a) -> F
eqt₂(pending, excl) -> F
eqt₂(pending, false) -> F
eqt₂(pending, lock) -> F
eqt₂(pending, locker) -> F
eqt₂(pending, mcrlrecord) -> F
eqt₂(pending, ok) -> F
eqt₂(pending, pending) -> T
eqt₂(pending, release) -> F
eqt₂(pending, request) -> F
eqt₂(pending, resource) -> F
eqt₂(pending, tag) -> F
eqt₂(pending, true) -> F
eqt₂(pending, undefined) -> F
eqt₂(pending, pid₁(N2)) -> F
eqt₂(pending, int₁(N2)) -> F
eqt₂(pending, cons₂(H2, T2)) -> F
eqt₂(pending, tuple₂(H2, T2)) -> F
eqt₂(pending, tuplenil₁(H2)) -> F
eqt₂(release, nil) -> F
eqt₂(release, a) -> F
eqt₂(release, excl) -> F
eqt₂(release, false) -> F
eqt₂(release, lock) -> F
eqt₂(release, locker) -> F
eqt₂(release, mcrlrecord) -> F
eqt₂(release, ok) -> F
eqt₂(request, mcrlrecord) -> F
eqt₂(request, ok) -> F
eqt₂(request, pending) -> F
eqt₂(request, release) -> F
eqt₂(request, request) -> T
eqt₂(request, resource) -> F
eqt₂(request, tag) -> F
eqt₂(request, true) -> F
eqt₂(request, undefined) -> F
eqt₂(request, pid₁(N2)) -> F
eqt₂(request, int₁(N2)) -> F
eqt₂(request, cons₂(H2, T2)) -> F
eqt₂(request, tuple₂(H2, T2)) -> F
eqt₂(request, tuplenil₁(H2)) -> F
eqt₂(resource, nil) -> F
eqt₂(resource, a) -> F
eqt₂(resource, excl) -> F
eqt₂(resource, false) -> F
eqt₂(resource, lock) -> F
eqt₂(resource, locker) -> F
eqt₂(resource, mcrlrecord) -> F
eqt₂(resource, ok) -> F
eqt₂(resource, pending) -> F
eqt₂(resource, release) -> F
eqt₂(resource, request) -> F
eqt₂(resource, resource) -> T
eqt₂(resource, tag) -> F
eqt₂(resource, true) -> F
eqt₂(resource, undefined) -> F
eqt₂(resource, pid₁(N2)) -> F
eqt₂(resource, int₁(N2)) -> F
eqt₂(resource, cons₂(H2, T2)) -> F
eqt₂(resource, tuple₂(H2, T2)) -> F
eqt₂(resource, tuplenil₁(H2)) -> F
eqt₂(tag, nil) -> F
eqt₂(tag, a) -> F
eqt₂(tag, excl) -> F
eqt₂(tag, false) -> F
eqt₂(tag, lock) -> F
eqt₂(tag, locker) -> F
eqt₂(tag, mcrlrecord) -> F
eqt₂(tag, ok) -> F
eqt₂(tag, pending) -> F
eqt₂(tag, release) -> F
eqt₂(tag, request) -> F
eqt₂(tag, resource) -> F
eqt₂(tag, tag) -> T
eqt₂(tag, true) -> F
eqt₂(tag, undefined) -> F
eqt₂(tag, pid₁(N2)) -> F
eqt₂(tag, int₁(N2)) -> F
eqt₂(tag, cons₂(H2, T2)) -> F
eqt₂(tag, tuple₂(H2, T2)) -> F
eqt₂(tag, tuplenil₁(H2)) -> F
eqt₂(true, nil) -> F
eqt₂(true, a) -> F
eqt₂(true, excl) -> F
eqt₂(true, false) -> F
eqt₂(true, lock) -> F
eqt₂(true, locker) -> F
eqt₂(true, mcrlrecord) -> F
eqt₂(true, ok) -> F
eqt₂(true, pending) -> F
eqt₂(true, release) -> F
eqt₂(true, request) -> F
eqt₂(true, resource) -> F
eqt₂(true, tag) -> F
eqt₂(true, true) -> T
eqt₂(true, undefined) -> F
eqt₂(true, pid₁(N2)) -> F
eqt₂(true, int₁(N2)) -> F
eqt₂(true, cons₂(H2, T2)) -> F
eqt₂(true, tuple₂(H2, T2)) -> F
eqt₂(true, tuplenil₁(H2)) -> F
eqt₂(undefined, nil) -> F
eqt₂(undefined, a) -> F
eqt₂(undefined, tuplenil₁(H2)) -> F
eqt₂(pid₁(N1), nil) -> F
eqt₂(pid₁(N1), a) -> F
eqt₂(pid₁(N1), excl) -> F
eqt₂(pid₁(N1), false) -> F
eqt₂(pid₁(N1), lock) -> F
eqt₂(pid₁(N1), locker) -> F
eqt₂(pid₁(N1), mcrlrecord) -> F
eqt₂(pid₁(N1), ok) -> F
eqt₂(pid₁(N1), pending) -> F
eqt₂(pid₁(N1), release) -> F
eqt₂(pid₁(N1), request) -> F
eqt₂(pid₁(N1), resource) -> F
eqt₂(pid₁(N1), tag) -> F
eqt₂(pid₁(N1), true) -> F
eqt₂(pid₁(N1), undefined) -> F
eqt₂(pid₁(N1), pid₁(N2)) -> eqt₂(N1, N2)
eqt₂(pid₁(N1), int₁(N2)) -> F
eqt₂(pid₁(N1), cons₂(H2, T2)) -> F
eqt₂(pid₁(N1), tuple₂(H2, T2)) -> F
eqt₂(pid₁(N1), tuplenil₁(H2)) -> F
eqt₂(int₁(N1), nil) -> F
eqt₂(int₁(N1), a) -> F
eqt₂(int₁(N1), excl) -> F
eqt₂(int₁(N1), false) -> F
eqt₂(int₁(N1), lock) -> F
eqt₂(int₁(N1), locker) -> F
eqt₂(int₁(N1), mcrlrecord) -> F
eqt₂(int₁(N1), ok) -> F
eqt₂(int₁(N1), pending) -> F
eqt₂(int₁(N1), release) -> F
eqt₂(int₁(N1), request) -> F
eqt₂(int₁(N1), resource) -> F
eqt₂(int₁(N1), tag) -> F
eqt₂(int₁(N1), true) -> F
eqt₂(int₁(N1), undefined) -> F
eqt₂(cons₂(H1, T1), resource) -> F
eqt₂(cons₂(H1, T1), tag) -> F
eqt₂(cons₂(H1, T1), true) -> F
eqt₂(cons₂(H1, T1), undefined) -> F
eqt₂(cons₂(H1, T1), pid₁(N2)) -> F
eqt₂(cons₂(H1, T1), int₁(N2)) -> F
eqt₂(cons₂(H1, T1), cons₂(H2, T2)) -> and₂(eqt₂(H1, H2), eqt₂(T1, T2))
eqt₂(cons₂(H1, T1), tuple₂(H2, T2)) -> F
eqt₂(cons₂(H1, T1), tuplenil₁(H2)) -> F
eqt₂(tuple₂(H1, T1), nil) -> F
eqt₂(tuple₂(H1, T1), a) -> F
eqt₂(tuple₂(H1, T1), excl) -> F
eqt₂(tuple₂(H1, T1), false) -> F
eqt₂(tuple₂(H1, T1), lock) -> F
eqt₂(tuple₂(H1, T1), locker) -> F
eqt₂(tuple₂(H1, T1), mcrlrecord) -> F
eqt₂(tuple₂(H1, T1), ok) -> F
eqt₂(tuple₂(H1, T1), pending) -> F
eqt₂(tuple₂(H1, T1), release) -> F
eqt₂(tuple₂(H1, T1), request) -> F
eqt₂(tuple₂(H1, T1), resource) -> F
eqt₂(tuple₂(H1, T1), tag) -> F
eqt₂(tuple₂(H1, T1), true) -> F
eqt₂(tuple₂(H1, T1), undefined) -> F
eqt₂(tuple₂(H1, T1), pid₁(N2)) -> F
eqt₂(tuple₂(H1, T1), int₁(N2)) -> F
eqt₂(tuple₂(H1, T1), cons₂(H2, T2)) -> F
eqt₂(tuple₂(H1, T1), tuple₂(H2, T2)) -> and₂(eqt₂(H1, H2), eqt₂(T1, T2))
eqt₂(tuple₂(H1, T1), tuplenil₁(H2)) -> F
eqt₂(tuplenil₁(H1), nil) -> F
eqt₂(tuplenil₁(H1), a) -> F
eqt₂(tuplenil₁(H1), excl) -> F
eqt₂(tuplenil₁(H1), false) -> F
eqt₂(tuplenil₁(H1), lock) -> F
eqt₂(tuplenil₁(H1), locker) -> F
eqt₂(tuplenil₁(H1), mcrlrecord) -> F
eqt₂(tuplenil₁(H1), ok) -> F
eqt₂(tuplenil₁(H1), pending) -> F
eqt₂(tuplenil₁(H1), release) -> F
eqt₂(tuplenil₁(H1), request) -> F
eqt₂(tuplenil₁(H1), resource) -> F
eqt₂(tuplenil₁(H1), tag) -> F
eqt₂(tuplenil₁(H1), true) -> F
eqt₂(tuplenil₁(H1), undefined) -> F
eqt₂(tuplenil₁(H1), pid₁(N2)) -> F
eqt₂(tuplenil₁(H1), int₁(N2)) -> F
eqt₂(tuplenil₁(H1), cons₂(H2, T2)) -> F
eqt₂(tuplenil₁(H1), tuple₂(H2, T2)) -> F
eqt₂(tuplenil₁(H1), tuplenil₁(H2)) -> eqt₂(H1, H2)
element₂(int₁(s₁(0)), tuplenil₁(T1)) -> T1
element₂(int₁(s₁(0)), tuple₂(T1, T2)) -> T1
element₂(int₁(s₁(s₁(N1))), tuple₂(T1, T2)) -> element₂(int₁(s₁(N1)), T2)
record_new₁(lock) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(undefined, tuple₂(nil, tuplenil₁(nil)))))
record_extract₃(tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2))))), lock, resource) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2)))))
record_update₄(tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2))))), lock, pending, NewF) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(NewF)))))
record_updates₃(Record, Name, nil) -> Record
record_updates₃(Record, Name, cons₂(tuple₂(Field, tuplenil₁(NewF)), Fields)) -> record_updates₃(record_update₄(Record, Name, Field, NewF), Name, Fields)
locker2_map_promote_pending₂(nil, Pending) -> nil
locker2_map_promote_pending₂(cons₂(Lock, Locks), Pending) -> cons₂(locker2_promote_pending₂(Lock, Pending), locker2_map_promote_pending₂(Locks, Pending))
locker2_map_claim_lock₃(nil, Resources, Client) -> nil
locker2_map_claim_lock₃(cons₂(Lock, Locks), Resources, Client) -> cons₂(locker2_claim_lock₃(Lock, Resources, Client), locker2_map_claim_lock₃(Locks, Resources, Client))
locker2_map_add_pending₃(nil, Resources, Client) -> nil
locker2_promote_pending₂(Lock, Client) -> case0₃(Client, Lock, record_extract₃(Lock, lock, pending))
case0₃(Client, Lock, cons₂(Client, Pendings)) -> record_updates₃(Lock, lock, cons₂(tuple₂(excl, tuplenil₁(Client)), cons₂(tuple₂(pending, tuplenil₁(Pendings)), nil)))
case0₃(Client, Lock, MCRLFree0) -> Lock
locker2_remove_pending₂(Lock, Client) -> record_updates₃(Lock, lock, cons₂(tuple₂(pending, tuplenil₁(subtract₂(record_extract₃(Lock, lock, pending), cons₂(Client, nil)))), nil))
locker2_add_pending₃(Lock, Resources, Client) -> case1₄(Client, Resources, Lock, member₂(record_extract₃(Lock, lock, resource), Resources))
case1₄(Client, Resources, Lock, true) -> record_updates₃(Lock, lock, cons₂(tuple₂(pending, tuplenil₁(append₂(record_extract₃(Lock, lock, pending), cons₂(Client, nil)))), nil))
case1₄(Client, Resources, Lock, false) -> Lock
locker2_release_lock₂(Lock, Client) -> case2₃(Client, Lock, gen_modtageq₂(Client, record_extract₃(Lock, lock, excl)))
case2₃(Client, Lock, true) -> record_updates₃(Lock, lock, cons₂(tuple₂(excllock, excl), nil))
case4₃(Client, Lock, MCRLFree1) -> false
locker2_obtainables₂(nil, Client) -> true
locker2_obtainables₂(cons₂(Lock, Locks), Client) -> case5₄(Client, Locks, Lock, member₂(Client, record_extract₃(Lock, lock, pending)))
case5₄(Client, Locks, Lock, true) -> andt₂(locker2_obtainable₂(Lock, Client), locker2_obtainables₂(Locks, Client))
case5₄(Client, Locks, Lock, false) -> locker2_obtainables₂(Locks, Client)
locker2_check_available₂(Resource, nil) -> false
locker2_check_available₂(Resource, cons₂(Lock, Locks)) -> case6₄(Locks, Lock, Resource, equal₂(Resource, record_extract₃(Lock, lock, resource)))
case6₄(Locks, Lock, Resource, true) -> andt₂(equal₂(record_extract₃(Lock, lock, excl), nil), equal₂(record_extract₃(Lock, lock, pending), nil))
case6₄(Locks, Lock, Resource, false) -> locker2_check_available₂(Resource, Locks)
locker2_check_availables₂(nil, Locks) -> true
locker2_check_availables₂(cons₂(Resource, Resources), Locks) -> andt₂(locker2_check_available₂(Resource, Locks), locker2_check_availables₂(Resources, Locks))
locker2_adduniq₂(nil, List) -> List
append₂(cons₂(Head, Tail), List) -> cons₂(Head, append₂(Tail, List))
subtract₂(List, nil) -> List
subtract₂(List, cons₂(Head, Tail)) -> subtract₂(delete₂(Head, List), Tail)
delete₂(E, nil) -> nil
delete₂(E, cons₂(Head, Tail)) -> case8₄(Tail, Head, E, equal₂(E, Head))
case8₄(Tail, Head, E, true) -> Tail
case8₄(Tail, Head, E, false) -> cons₂(Head, delete₂(E, Tail))
gen_tag₁(Pid) -> tuple₂(Pid, tuplenil₁(tag))
gen_modtageq₂(Client1, Client2) -> equal₂(Client1, Client2)
member₂(E, nil) -> false
member₂(E, cons₂(Head, Tail)) -> case9₄(Tail, Head, E, equal₂(E, Head))
case9₄(Tail, Head, E, true) -> true
case9₄(Tail, Head, E, false) -> member₂(E, Tail)
eqs₂(empty, empty) -> T
eqs₂(empty, stack₂(E2, S2)) -> F
eqs₂(stack₂(E1, S1), empty) -> F
eqs₂(stack₂(E1, S1), stack₂(E2, S2)) -> and₂(eqt₂(E1, E2), eqs₂(S1, S2))
pushs₂(E1, S1) -> stack₂(E1, S1)
pops₁(stack₂(E1, S1)) -> S1
tops₁(stack₂(E1, S1)) -> E1
istops₂(E1, empty) -> F
istops₂(E1, stack₂(E2, S1)) -> eqt₂(E1, E2)
eqc₂(nocalls, nocalls) -> T
eqc₂(nocalls, calls₃(E2, S2, CS2)) -> F
eqc₂(calls₃(E1, S1, CS1), nocalls) -> F
eqc₂(calls₃(E1, S1, CS1), calls₃(E2, S2, CS2)) -> and₂(eqt₂(E1, E2), and₂(eqs₂(S1, S2), eqc₂(CS1, CS2)))
push₃(E1, E2, nocalls) -> calls₃(E1, stack₂(E2, empty), nocalls)
push₃(E1, E2, calls₃(E3, S1, CS1)) -> push1₆(E1, E2, E3, S1, CS1, eqt₂(E1, E3))
push1₆(E1, E2, E3, S1, CS1, T) -> calls₃(E3, pushs₂(E2, S1), CS1)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

LOCKER2_MAP_PROMOTE_PENDING₂(cons₂(Lock, Locks), Pending) -> LOCKER2_MAP_PROMOTE_PENDING₂(Locks, Pending)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial Order [17,21] with Interpretation:

POL( cons₂(x₁, x₂) ) = x₁ + x₂ + 1

POL( LOCKER2_MAP_PROMOTE_PENDING₂(x₁, x₂) ) = x₁ + x₂

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

or₂(T, T) -> T
or₂(F, T) -> T
or₂(T, F) -> T
or₂(F, F) -> F
and₂(T, B) -> B
and₂(B, T) -> B
and₂(F, B) -> F
and₂(B, F) -> F
imp₂(T, B) -> B
imp₂(F, B) -> T
not₁(T) -> F
not₁(F) -> T
if₃(T, B1, B2) -> B1
if₃(F, B1, B2) -> B2
eq₂(T, T) -> T
eq₂(F, F) -> T
eq₂(T, F) -> F
eq₂(F, T) -> F
eqt₂(nil, undefined) -> F
eqt₂(nil, pid₁(N2)) -> F
eqt₂(nil, int₁(N2)) -> F
eqt₂(nil, cons₂(H2, T2)) -> F
eqt₂(nil, tuple₂(H2, T2)) -> F
eqt₂(nil, tuplenil₁(H2)) -> F
eqt₂(a, nil) -> F
eqt₂(a, a) -> T
eqt₂(a, excl) -> F
eqt₂(a, false) -> F
eqt₂(a, lock) -> F
eqt₂(a, locker) -> F
eqt₂(a, mcrlrecord) -> F
eqt₂(a, ok) -> F
eqt₂(a, pending) -> F
eqt₂(a, release) -> F
eqt₂(a, request) -> F
eqt₂(a, resource) -> F
eqt₂(a, tag) -> F
eqt₂(a, true) -> F
eqt₂(a, undefined) -> F
eqt₂(a, pid₁(N2)) -> F
eqt₂(a, int₁(N2)) -> F
eqt₂(a, cons₂(H2, T2)) -> F
eqt₂(a, tuple₂(H2, T2)) -> F
eqt₂(a, tuplenil₁(H2)) -> F
eqt₂(excl, nil) -> F
eqt₂(excl, a) -> F
eqt₂(excl, excl) -> T
eqt₂(excl, false) -> F
eqt₂(excl, lock) -> F
eqt₂(excl, locker) -> F
eqt₂(excl, mcrlrecord) -> F
eqt₂(excl, ok) -> F
eqt₂(excl, pending) -> F
eqt₂(excl, release) -> F
eqt₂(excl, request) -> F
eqt₂(excl, resource) -> F
eqt₂(excl, tag) -> F
eqt₂(excl, true) -> F
eqt₂(excl, undefined) -> F
eqt₂(excl, pid₁(N2)) -> F
eqt₂(excl, eqt₂(false, int₁(N2))) -> F
eqt₂(false, cons₂(H2, T2)) -> F
eqt₂(false, tuple₂(H2, T2)) -> F
eqt₂(false, tuplenil₁(H2)) -> F
eqt₂(lock, nil) -> F
eqt₂(lock, a) -> F
eqt₂(lock, excl) -> F
eqt₂(lock, false) -> F
eqt₂(lock, lock) -> T
eqt₂(lock, locker) -> F
eqt₂(lock, mcrlrecord) -> F
eqt₂(lock, ok) -> F
eqt₂(lock, pending) -> F
eqt₂(lock, release) -> F
eqt₂(lock, request) -> F
eqt₂(lock, resource) -> F
eqt₂(lock, tag) -> F
eqt₂(lock, true) -> F
eqt₂(lock, undefined) -> F
eqt₂(lock, pid₁(N2)) -> F
eqt₂(lock, int₁(N2)) -> F
eqt₂(lock, cons₂(H2, T2)) -> F
eqt₂(lock, tuple₂(H2, T2)) -> F
eqt₂(lock, tuplenil₁(H2)) -> F
eqt₂(locker, nil) -> F
eqt₂(locker, a) -> F
eqt₂(locker, excl) -> F
eqt₂(locker, false) -> F
eqt₂(locker, lock) -> F
eqt₂(locker, locker) -> T
eqt₂(locker, mcrlrecord) -> F
eqt₂(locker, ok) -> F
eqt₂(locker, pending) -> F
eqt₂(locker, release) -> F
eqt₂(locker, request) -> F
eqt₂(locker, resource) -> F
eqt₂(locker, tag) -> F
eqt₂(locker, true) -> F
eqt₂(locker, undefined) -> F
eqt₂(locker, pid₁(N2)) -> F
eqt₂(locker, int₁(N2)) -> F
eqt₂(locker, cons₂(H2, T2)) -> F
eqt₂(locker, tuple₂(H2, T2)) -> F
eqt₂(locker, tuplenil₁(H2)) -> F
eqt₂(mcrlrecord, nil) -> F
eqt₂(mcrlrecord, a) -> F
eqt₂(mcrlrecord, excl) -> F
eqt₂(mcrlrecord, false) -> F
eqt₂(mcrlrecord, lock) -> F
eqt₂(mcrlrecord, locker) -> F
eqt₂(mcrlrecord, mcrlrecord) -> T
eqt₂(mcrlrecord, ok) -> F
eqt₂(mcrlrecord, pending) -> F
eqt₂(mcrlrecord, release) -> F
eqt₂(mcrlrecord, request) -> F
eqt₂(mcrlrecord, resource) -> F
eqt₂(ok, resource) -> F
eqt₂(ok, tag) -> F
eqt₂(ok, true) -> F
eqt₂(ok, undefined) -> F
eqt₂(ok, pid₁(N2)) -> F
eqt₂(ok, int₁(N2)) -> F
eqt₂(ok, cons₂(H2, T2)) -> F
eqt₂(ok, tuple₂(H2, T2)) -> F
eqt₂(ok, tuplenil₁(H2)) -> F
eqt₂(pending, nil) -> F
eqt₂(pending, a) -> F
eqt₂(pending, excl) -> F
eqt₂(pending, false) -> F
eqt₂(pending, lock) -> F
eqt₂(pending, locker) -> F
eqt₂(pending, mcrlrecord) -> F
eqt₂(pending, ok) -> F
eqt₂(pending, pending) -> T
eqt₂(pending, release) -> F
eqt₂(pending, request) -> F
eqt₂(pending, resource) -> F
eqt₂(pending, tag) -> F
eqt₂(pending, true) -> F
eqt₂(pending, undefined) -> F
eqt₂(pending, pid₁(N2)) -> F
eqt₂(pending, int₁(N2)) -> F
eqt₂(pending, cons₂(H2, T2)) -> F
eqt₂(pending, tuple₂(H2, T2)) -> F
eqt₂(pending, tuplenil₁(H2)) -> F
eqt₂(release, nil) -> F
eqt₂(release, a) -> F
eqt₂(release, excl) -> F
eqt₂(release, false) -> F
eqt₂(release, lock) -> F
eqt₂(release, locker) -> F
eqt₂(release, mcrlrecord) -> F
eqt₂(release, ok) -> F
eqt₂(request, mcrlrecord) -> F
eqt₂(request, ok) -> F
eqt₂(request, pending) -> F
eqt₂(request, release) -> F
eqt₂(request, request) -> T
eqt₂(request, resource) -> F
eqt₂(request, tag) -> F
eqt₂(request, true) -> F
eqt₂(request, undefined) -> F
eqt₂(request, pid₁(N2)) -> F
eqt₂(request, int₁(N2)) -> F
eqt₂(request, cons₂(H2, T2)) -> F
eqt₂(request, tuple₂(H2, T2)) -> F
eqt₂(request, tuplenil₁(H2)) -> F
eqt₂(resource, nil) -> F
eqt₂(resource, a) -> F
eqt₂(resource, excl) -> F
eqt₂(resource, false) -> F
eqt₂(resource, lock) -> F
eqt₂(resource, locker) -> F
eqt₂(resource, mcrlrecord) -> F
eqt₂(resource, ok) -> F
eqt₂(resource, pending) -> F
eqt₂(resource, release) -> F
eqt₂(resource, request) -> F
eqt₂(resource, resource) -> T
eqt₂(resource, tag) -> F
eqt₂(resource, true) -> F
eqt₂(resource, undefined) -> F
eqt₂(resource, pid₁(N2)) -> F
eqt₂(resource, int₁(N2)) -> F
eqt₂(resource, cons₂(H2, T2)) -> F
eqt₂(resource, tuple₂(H2, T2)) -> F
eqt₂(resource, tuplenil₁(H2)) -> F
eqt₂(tag, nil) -> F
eqt₂(tag, a) -> F
eqt₂(tag, excl) -> F
eqt₂(tag, false) -> F
eqt₂(tag, lock) -> F
eqt₂(tag, locker) -> F
eqt₂(tag, mcrlrecord) -> F
eqt₂(tag, ok) -> F
eqt₂(tag, pending) -> F
eqt₂(tag, release) -> F
eqt₂(tag, request) -> F
eqt₂(tag, resource) -> F
eqt₂(tag, tag) -> T
eqt₂(tag, true) -> F
eqt₂(tag, undefined) -> F
eqt₂(tag, pid₁(N2)) -> F
eqt₂(tag, int₁(N2)) -> F
eqt₂(tag, cons₂(H2, T2)) -> F
eqt₂(tag, tuple₂(H2, T2)) -> F
eqt₂(tag, tuplenil₁(H2)) -> F
eqt₂(true, nil) -> F
eqt₂(true, a) -> F
eqt₂(true, excl) -> F
eqt₂(true, false) -> F
eqt₂(true, lock) -> F
eqt₂(true, locker) -> F
eqt₂(true, mcrlrecord) -> F
eqt₂(true, ok) -> F
eqt₂(true, pending) -> F
eqt₂(true, release) -> F
eqt₂(true, request) -> F
eqt₂(true, resource) -> F
eqt₂(true, tag) -> F
eqt₂(true, true) -> T
eqt₂(true, undefined) -> F
eqt₂(true, pid₁(N2)) -> F
eqt₂(true, int₁(N2)) -> F
eqt₂(true, cons₂(H2, T2)) -> F
eqt₂(true, tuple₂(H2, T2)) -> F
eqt₂(true, tuplenil₁(H2)) -> F
eqt₂(undefined, nil) -> F
eqt₂(undefined, a) -> F
eqt₂(undefined, tuplenil₁(H2)) -> F
eqt₂(pid₁(N1), nil) -> F
eqt₂(pid₁(N1), a) -> F
eqt₂(pid₁(N1), excl) -> F
eqt₂(pid₁(N1), false) -> F
eqt₂(pid₁(N1), lock) -> F
eqt₂(pid₁(N1), locker) -> F
eqt₂(pid₁(N1), mcrlrecord) -> F
eqt₂(pid₁(N1), ok) -> F
eqt₂(pid₁(N1), pending) -> F
eqt₂(pid₁(N1), release) -> F
eqt₂(pid₁(N1), request) -> F
eqt₂(pid₁(N1), resource) -> F
eqt₂(pid₁(N1), tag) -> F
eqt₂(pid₁(N1), true) -> F
eqt₂(pid₁(N1), undefined) -> F
eqt₂(pid₁(N1), pid₁(N2)) -> eqt₂(N1, N2)
eqt₂(pid₁(N1), int₁(N2)) -> F
eqt₂(pid₁(N1), cons₂(H2, T2)) -> F
eqt₂(pid₁(N1), tuple₂(H2, T2)) -> F
eqt₂(pid₁(N1), tuplenil₁(H2)) -> F
eqt₂(int₁(N1), nil) -> F
eqt₂(int₁(N1), a) -> F
eqt₂(int₁(N1), excl) -> F
eqt₂(int₁(N1), false) -> F
eqt₂(int₁(N1), lock) -> F
eqt₂(int₁(N1), locker) -> F
eqt₂(int₁(N1), mcrlrecord) -> F
eqt₂(int₁(N1), ok) -> F
eqt₂(int₁(N1), pending) -> F
eqt₂(int₁(N1), release) -> F
eqt₂(int₁(N1), request) -> F
eqt₂(int₁(N1), resource) -> F
eqt₂(int₁(N1), tag) -> F
eqt₂(int₁(N1), true) -> F
eqt₂(int₁(N1), undefined) -> F
eqt₂(cons₂(H1, T1), resource) -> F
eqt₂(cons₂(H1, T1), tag) -> F
eqt₂(cons₂(H1, T1), true) -> F
eqt₂(cons₂(H1, T1), undefined) -> F
eqt₂(cons₂(H1, T1), pid₁(N2)) -> F
eqt₂(cons₂(H1, T1), int₁(N2)) -> F
eqt₂(cons₂(H1, T1), cons₂(H2, T2)) -> and₂(eqt₂(H1, H2), eqt₂(T1, T2))
eqt₂(cons₂(H1, T1), tuple₂(H2, T2)) -> F
eqt₂(cons₂(H1, T1), tuplenil₁(H2)) -> F
eqt₂(tuple₂(H1, T1), nil) -> F
eqt₂(tuple₂(H1, T1), a) -> F
eqt₂(tuple₂(H1, T1), excl) -> F
eqt₂(tuple₂(H1, T1), false) -> F
eqt₂(tuple₂(H1, T1), lock) -> F
eqt₂(tuple₂(H1, T1), locker) -> F
eqt₂(tuple₂(H1, T1), mcrlrecord) -> F
eqt₂(tuple₂(H1, T1), ok) -> F
eqt₂(tuple₂(H1, T1), pending) -> F
eqt₂(tuple₂(H1, T1), release) -> F
eqt₂(tuple₂(H1, T1), request) -> F
eqt₂(tuple₂(H1, T1), resource) -> F
eqt₂(tuple₂(H1, T1), tag) -> F
eqt₂(tuple₂(H1, T1), true) -> F
eqt₂(tuple₂(H1, T1), undefined) -> F
eqt₂(tuple₂(H1, T1), pid₁(N2)) -> F
eqt₂(tuple₂(H1, T1), int₁(N2)) -> F
eqt₂(tuple₂(H1, T1), cons₂(H2, T2)) -> F
eqt₂(tuple₂(H1, T1), tuple₂(H2, T2)) -> and₂(eqt₂(H1, H2), eqt₂(T1, T2))
eqt₂(tuple₂(H1, T1), tuplenil₁(H2)) -> F
eqt₂(tuplenil₁(H1), nil) -> F
eqt₂(tuplenil₁(H1), a) -> F
eqt₂(tuplenil₁(H1), excl) -> F
eqt₂(tuplenil₁(H1), false) -> F
eqt₂(tuplenil₁(H1), lock) -> F
eqt₂(tuplenil₁(H1), locker) -> F
eqt₂(tuplenil₁(H1), mcrlrecord) -> F
eqt₂(tuplenil₁(H1), ok) -> F
eqt₂(tuplenil₁(H1), pending) -> F
eqt₂(tuplenil₁(H1), release) -> F
eqt₂(tuplenil₁(H1), request) -> F
eqt₂(tuplenil₁(H1), resource) -> F
eqt₂(tuplenil₁(H1), tag) -> F
eqt₂(tuplenil₁(H1), true) -> F
eqt₂(tuplenil₁(H1), undefined) -> F
eqt₂(tuplenil₁(H1), pid₁(N2)) -> F
eqt₂(tuplenil₁(H1), int₁(N2)) -> F
eqt₂(tuplenil₁(H1), cons₂(H2, T2)) -> F
eqt₂(tuplenil₁(H1), tuple₂(H2, T2)) -> F
eqt₂(tuplenil₁(H1), tuplenil₁(H2)) -> eqt₂(H1, H2)
element₂(int₁(s₁(0)), tuplenil₁(T1)) -> T1
element₂(int₁(s₁(0)), tuple₂(T1, T2)) -> T1
element₂(int₁(s₁(s₁(N1))), tuple₂(T1, T2)) -> element₂(int₁(s₁(N1)), T2)
record_new₁(lock) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(undefined, tuple₂(nil, tuplenil₁(nil)))))
record_extract₃(tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2))))), lock, resource) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2)))))
record_update₄(tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2))))), lock, pending, NewF) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(NewF)))))
record_updates₃(Record, Name, nil) -> Record
record_updates₃(Record, Name, cons₂(tuple₂(Field, tuplenil₁(NewF)), Fields)) -> record_updates₃(record_update₄(Record, Name, Field, NewF), Name, Fields)
locker2_map_promote_pending₂(nil, Pending) -> nil
locker2_map_promote_pending₂(cons₂(Lock, Locks), Pending) -> cons₂(locker2_promote_pending₂(Lock, Pending), locker2_map_promote_pending₂(Locks, Pending))
locker2_map_claim_lock₃(nil, Resources, Client) -> nil
locker2_map_claim_lock₃(cons₂(Lock, Locks), Resources, Client) -> cons₂(locker2_claim_lock₃(Lock, Resources, Client), locker2_map_claim_lock₃(Locks, Resources, Client))
locker2_map_add_pending₃(nil, Resources, Client) -> nil
locker2_promote_pending₂(Lock, Client) -> case0₃(Client, Lock, record_extract₃(Lock, lock, pending))
case0₃(Client, Lock, cons₂(Client, Pendings)) -> record_updates₃(Lock, lock, cons₂(tuple₂(excl, tuplenil₁(Client)), cons₂(tuple₂(pending, tuplenil₁(Pendings)), nil)))
case0₃(Client, Lock, MCRLFree0) -> Lock
locker2_remove_pending₂(Lock, Client) -> record_updates₃(Lock, lock, cons₂(tuple₂(pending, tuplenil₁(subtract₂(record_extract₃(Lock, lock, pending), cons₂(Client, nil)))), nil))
locker2_add_pending₃(Lock, Resources, Client) -> case1₄(Client, Resources, Lock, member₂(record_extract₃(Lock, lock, resource), Resources))
case1₄(Client, Resources, Lock, true) -> record_updates₃(Lock, lock, cons₂(tuple₂(pending, tuplenil₁(append₂(record_extract₃(Lock, lock, pending), cons₂(Client, nil)))), nil))
case1₄(Client, Resources, Lock, false) -> Lock
locker2_release_lock₂(Lock, Client) -> case2₃(Client, Lock, gen_modtageq₂(Client, record_extract₃(Lock, lock, excl)))
case2₃(Client, Lock, true) -> record_updates₃(Lock, lock, cons₂(tuple₂(excllock, excl), nil))
case4₃(Client, Lock, MCRLFree1) -> false
locker2_obtainables₂(nil, Client) -> true
locker2_obtainables₂(cons₂(Lock, Locks), Client) -> case5₄(Client, Locks, Lock, member₂(Client, record_extract₃(Lock, lock, pending)))
case5₄(Client, Locks, Lock, true) -> andt₂(locker2_obtainable₂(Lock, Client), locker2_obtainables₂(Locks, Client))
case5₄(Client, Locks, Lock, false) -> locker2_obtainables₂(Locks, Client)
locker2_check_available₂(Resource, nil) -> false
locker2_check_available₂(Resource, cons₂(Lock, Locks)) -> case6₄(Locks, Lock, Resource, equal₂(Resource, record_extract₃(Lock, lock, resource)))
case6₄(Locks, Lock, Resource, true) -> andt₂(equal₂(record_extract₃(Lock, lock, excl), nil), equal₂(record_extract₃(Lock, lock, pending), nil))
case6₄(Locks, Lock, Resource, false) -> locker2_check_available₂(Resource, Locks)
locker2_check_availables₂(nil, Locks) -> true
locker2_check_availables₂(cons₂(Resource, Resources), Locks) -> andt₂(locker2_check_available₂(Resource, Locks), locker2_check_availables₂(Resources, Locks))
locker2_adduniq₂(nil, List) -> List
append₂(cons₂(Head, Tail), List) -> cons₂(Head, append₂(Tail, List))
subtract₂(List, nil) -> List
subtract₂(List, cons₂(Head, Tail)) -> subtract₂(delete₂(Head, List), Tail)
delete₂(E, nil) -> nil
delete₂(E, cons₂(Head, Tail)) -> case8₄(Tail, Head, E, equal₂(E, Head))
case8₄(Tail, Head, E, true) -> Tail
case8₄(Tail, Head, E, false) -> cons₂(Head, delete₂(E, Tail))
gen_tag₁(Pid) -> tuple₂(Pid, tuplenil₁(tag))
gen_modtageq₂(Client1, Client2) -> equal₂(Client1, Client2)
member₂(E, nil) -> false
member₂(E, cons₂(Head, Tail)) -> case9₄(Tail, Head, E, equal₂(E, Head))
case9₄(Tail, Head, E, true) -> true
case9₄(Tail, Head, E, false) -> member₂(E, Tail)
eqs₂(empty, empty) -> T
eqs₂(empty, stack₂(E2, S2)) -> F
eqs₂(stack₂(E1, S1), empty) -> F
eqs₂(stack₂(E1, S1), stack₂(E2, S2)) -> and₂(eqt₂(E1, E2), eqs₂(S1, S2))
pushs₂(E1, S1) -> stack₂(E1, S1)
pops₁(stack₂(E1, S1)) -> S1
tops₁(stack₂(E1, S1)) -> E1
istops₂(E1, empty) -> F
istops₂(E1, stack₂(E2, S1)) -> eqt₂(E1, E2)
eqc₂(nocalls, nocalls) -> T
eqc₂(nocalls, calls₃(E2, S2, CS2)) -> F
eqc₂(calls₃(E1, S1, CS1), nocalls) -> F
eqc₂(calls₃(E1, S1, CS1), calls₃(E2, S2, CS2)) -> and₂(eqt₂(E1, E2), and₂(eqs₂(S1, S2), eqc₂(CS1, CS2)))
push₃(E1, E2, nocalls) -> calls₃(E1, stack₂(E2, empty), nocalls)
push₃(E1, E2, calls₃(E3, S1, CS1)) -> push1₆(E1, E2, E3, S1, CS1, eqt₂(E1, E3))
push1₆(E1, E2, E3, S1, CS1, T) -> calls₃(E3, pushs₂(E2, S1), CS1)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

ELEMENT₂(int₁(s₁(s₁(N1))), tuple₂(T1, T2)) -> ELEMENT₂(int₁(s₁(N1)), T2)

The TRS R consists of the following rules:

or₂(T, T) -> T
or₂(F, T) -> T
or₂(T, F) -> T
or₂(F, F) -> F
and₂(T, B) -> B
and₂(B, T) -> B
and₂(F, B) -> F
and₂(B, F) -> F
imp₂(T, B) -> B
imp₂(F, B) -> T
not₁(T) -> F
not₁(F) -> T
if₃(T, B1, B2) -> B1
if₃(F, B1, B2) -> B2
eq₂(T, T) -> T
eq₂(F, F) -> T
eq₂(T, F) -> F
eq₂(F, T) -> F
eqt₂(nil, undefined) -> F
eqt₂(nil, pid₁(N2)) -> F
eqt₂(nil, int₁(N2)) -> F
eqt₂(nil, cons₂(H2, T2)) -> F
eqt₂(nil, tuple₂(H2, T2)) -> F
eqt₂(nil, tuplenil₁(H2)) -> F
eqt₂(a, nil) -> F
eqt₂(a, a) -> T
eqt₂(a, excl) -> F
eqt₂(a, false) -> F
eqt₂(a, lock) -> F
eqt₂(a, locker) -> F
eqt₂(a, mcrlrecord) -> F
eqt₂(a, ok) -> F
eqt₂(a, pending) -> F
eqt₂(a, release) -> F
eqt₂(a, request) -> F
eqt₂(a, resource) -> F
eqt₂(a, tag) -> F
eqt₂(a, true) -> F
eqt₂(a, undefined) -> F
eqt₂(a, pid₁(N2)) -> F
eqt₂(a, int₁(N2)) -> F
eqt₂(a, cons₂(H2, T2)) -> F
eqt₂(a, tuple₂(H2, T2)) -> F
eqt₂(a, tuplenil₁(H2)) -> F
eqt₂(excl, nil) -> F
eqt₂(excl, a) -> F
eqt₂(excl, excl) -> T
eqt₂(excl, false) -> F
eqt₂(excl, lock) -> F
eqt₂(excl, locker) -> F
eqt₂(excl, mcrlrecord) -> F
eqt₂(excl, ok) -> F
eqt₂(excl, pending) -> F
eqt₂(excl, release) -> F
eqt₂(excl, request) -> F
eqt₂(excl, resource) -> F
eqt₂(excl, tag) -> F
eqt₂(excl, true) -> F
eqt₂(excl, undefined) -> F
eqt₂(excl, pid₁(N2)) -> F
eqt₂(excl, eqt₂(false, int₁(N2))) -> F
eqt₂(false, cons₂(H2, T2)) -> F
eqt₂(false, tuple₂(H2, T2)) -> F
eqt₂(false, tuplenil₁(H2)) -> F
eqt₂(lock, nil) -> F
eqt₂(lock, a) -> F
eqt₂(lock, excl) -> F
eqt₂(lock, false) -> F
eqt₂(lock, lock) -> T
eqt₂(lock, locker) -> F
eqt₂(lock, mcrlrecord) -> F
eqt₂(lock, ok) -> F
eqt₂(lock, pending) -> F
eqt₂(lock, release) -> F
eqt₂(lock, request) -> F
eqt₂(lock, resource) -> F
eqt₂(lock, tag) -> F
eqt₂(lock, true) -> F
eqt₂(lock, undefined) -> F
eqt₂(lock, pid₁(N2)) -> F
eqt₂(lock, int₁(N2)) -> F
eqt₂(lock, cons₂(H2, T2)) -> F
eqt₂(lock, tuple₂(H2, T2)) -> F
eqt₂(lock, tuplenil₁(H2)) -> F
eqt₂(locker, nil) -> F
eqt₂(locker, a) -> F
eqt₂(locker, excl) -> F
eqt₂(locker, false) -> F
eqt₂(locker, lock) -> F
eqt₂(locker, locker) -> T
eqt₂(locker, mcrlrecord) -> F
eqt₂(locker, ok) -> F
eqt₂(locker, pending) -> F
eqt₂(locker, release) -> F
eqt₂(locker, request) -> F
eqt₂(locker, resource) -> F
eqt₂(locker, tag) -> F
eqt₂(locker, true) -> F
eqt₂(locker, undefined) -> F
eqt₂(locker, pid₁(N2)) -> F
eqt₂(locker, int₁(N2)) -> F
eqt₂(locker, cons₂(H2, T2)) -> F
eqt₂(locker, tuple₂(H2, T2)) -> F
eqt₂(locker, tuplenil₁(H2)) -> F
eqt₂(mcrlrecord, nil) -> F
eqt₂(mcrlrecord, a) -> F
eqt₂(mcrlrecord, excl) -> F
eqt₂(mcrlrecord, false) -> F
eqt₂(mcrlrecord, lock) -> F
eqt₂(mcrlrecord, locker) -> F
eqt₂(mcrlrecord, mcrlrecord) -> T
eqt₂(mcrlrecord, ok) -> F
eqt₂(mcrlrecord, pending) -> F
eqt₂(mcrlrecord, release) -> F
eqt₂(mcrlrecord, request) -> F
eqt₂(mcrlrecord, resource) -> F
eqt₂(ok, resource) -> F
eqt₂(ok, tag) -> F
eqt₂(ok, true) -> F
eqt₂(ok, undefined) -> F
eqt₂(ok, pid₁(N2)) -> F
eqt₂(ok, int₁(N2)) -> F
eqt₂(ok, cons₂(H2, T2)) -> F
eqt₂(ok, tuple₂(H2, T2)) -> F
eqt₂(ok, tuplenil₁(H2)) -> F
eqt₂(pending, nil) -> F
eqt₂(pending, a) -> F
eqt₂(pending, excl) -> F
eqt₂(pending, false) -> F
eqt₂(pending, lock) -> F
eqt₂(pending, locker) -> F
eqt₂(pending, mcrlrecord) -> F
eqt₂(pending, ok) -> F
eqt₂(pending, pending) -> T
eqt₂(pending, release) -> F
eqt₂(pending, request) -> F
eqt₂(pending, resource) -> F
eqt₂(pending, tag) -> F
eqt₂(pending, true) -> F
eqt₂(pending, undefined) -> F
eqt₂(pending, pid₁(N2)) -> F
eqt₂(pending, int₁(N2)) -> F
eqt₂(pending, cons₂(H2, T2)) -> F
eqt₂(pending, tuple₂(H2, T2)) -> F
eqt₂(pending, tuplenil₁(H2)) -> F
eqt₂(release, nil) -> F
eqt₂(release, a) -> F
eqt₂(release, excl) -> F
eqt₂(release, false) -> F
eqt₂(release, lock) -> F
eqt₂(release, locker) -> F
eqt₂(release, mcrlrecord) -> F
eqt₂(release, ok) -> F
eqt₂(request, mcrlrecord) -> F
eqt₂(request, ok) -> F
eqt₂(request, pending) -> F
eqt₂(request, release) -> F
eqt₂(request, request) -> T
eqt₂(request, resource) -> F
eqt₂(request, tag) -> F
eqt₂(request, true) -> F
eqt₂(request, undefined) -> F
eqt₂(request, pid₁(N2)) -> F
eqt₂(request, int₁(N2)) -> F
eqt₂(request, cons₂(H2, T2)) -> F
eqt₂(request, tuple₂(H2, T2)) -> F
eqt₂(request, tuplenil₁(H2)) -> F
eqt₂(resource, nil) -> F
eqt₂(resource, a) -> F
eqt₂(resource, excl) -> F
eqt₂(resource, false) -> F
eqt₂(resource, lock) -> F
eqt₂(resource, locker) -> F
eqt₂(resource, mcrlrecord) -> F
eqt₂(resource, ok) -> F
eqt₂(resource, pending) -> F
eqt₂(resource, release) -> F
eqt₂(resource, request) -> F
eqt₂(resource, resource) -> T
eqt₂(resource, tag) -> F
eqt₂(resource, true) -> F
eqt₂(resource, undefined) -> F
eqt₂(resource, pid₁(N2)) -> F
eqt₂(resource, int₁(N2)) -> F
eqt₂(resource, cons₂(H2, T2)) -> F
eqt₂(resource, tuple₂(H2, T2)) -> F
eqt₂(resource, tuplenil₁(H2)) -> F
eqt₂(tag, nil) -> F
eqt₂(tag, a) -> F
eqt₂(tag, excl) -> F
eqt₂(tag, false) -> F
eqt₂(tag, lock) -> F
eqt₂(tag, locker) -> F
eqt₂(tag, mcrlrecord) -> F
eqt₂(tag, ok) -> F
eqt₂(tag, pending) -> F
eqt₂(tag, release) -> F
eqt₂(tag, request) -> F
eqt₂(tag, resource) -> F
eqt₂(tag, tag) -> T
eqt₂(tag, true) -> F
eqt₂(tag, undefined) -> F
eqt₂(tag, pid₁(N2)) -> F
eqt₂(tag, int₁(N2)) -> F
eqt₂(tag, cons₂(H2, T2)) -> F
eqt₂(tag, tuple₂(H2, T2)) -> F
eqt₂(tag, tuplenil₁(H2)) -> F
eqt₂(true, nil) -> F
eqt₂(true, a) -> F
eqt₂(true, excl) -> F
eqt₂(true, false) -> F
eqt₂(true, lock) -> F
eqt₂(true, locker) -> F
eqt₂(true, mcrlrecord) -> F
eqt₂(true, ok) -> F
eqt₂(true, pending) -> F
eqt₂(true, release) -> F
eqt₂(true, request) -> F
eqt₂(true, resource) -> F
eqt₂(true, tag) -> F
eqt₂(true, true) -> T
eqt₂(true, undefined) -> F
eqt₂(true, pid₁(N2)) -> F
eqt₂(true, int₁(N2)) -> F
eqt₂(true, cons₂(H2, T2)) -> F
eqt₂(true, tuple₂(H2, T2)) -> F
eqt₂(true, tuplenil₁(H2)) -> F
eqt₂(undefined, nil) -> F
eqt₂(undefined, a) -> F
eqt₂(undefined, tuplenil₁(H2)) -> F
eqt₂(pid₁(N1), nil) -> F
eqt₂(pid₁(N1), a) -> F
eqt₂(pid₁(N1), excl) -> F
eqt₂(pid₁(N1), false) -> F
eqt₂(pid₁(N1), lock) -> F
eqt₂(pid₁(N1), locker) -> F
eqt₂(pid₁(N1), mcrlrecord) -> F
eqt₂(pid₁(N1), ok) -> F
eqt₂(pid₁(N1), pending) -> F
eqt₂(pid₁(N1), release) -> F
eqt₂(pid₁(N1), request) -> F
eqt₂(pid₁(N1), resource) -> F
eqt₂(pid₁(N1), tag) -> F
eqt₂(pid₁(N1), true) -> F
eqt₂(pid₁(N1), undefined) -> F
eqt₂(pid₁(N1), pid₁(N2)) -> eqt₂(N1, N2)
eqt₂(pid₁(N1), int₁(N2)) -> F
eqt₂(pid₁(N1), cons₂(H2, T2)) -> F
eqt₂(pid₁(N1), tuple₂(H2, T2)) -> F
eqt₂(pid₁(N1), tuplenil₁(H2)) -> F
eqt₂(int₁(N1), nil) -> F
eqt₂(int₁(N1), a) -> F
eqt₂(int₁(N1), excl) -> F
eqt₂(int₁(N1), false) -> F
eqt₂(int₁(N1), lock) -> F
eqt₂(int₁(N1), locker) -> F
eqt₂(int₁(N1), mcrlrecord) -> F
eqt₂(int₁(N1), ok) -> F
eqt₂(int₁(N1), pending) -> F
eqt₂(int₁(N1), release) -> F
eqt₂(int₁(N1), request) -> F
eqt₂(int₁(N1), resource) -> F
eqt₂(int₁(N1), tag) -> F
eqt₂(int₁(N1), true) -> F
eqt₂(int₁(N1), undefined) -> F
eqt₂(cons₂(H1, T1), resource) -> F
eqt₂(cons₂(H1, T1), tag) -> F
eqt₂(cons₂(H1, T1), true) -> F
eqt₂(cons₂(H1, T1), undefined) -> F
eqt₂(cons₂(H1, T1), pid₁(N2)) -> F
eqt₂(cons₂(H1, T1), int₁(N2)) -> F
eqt₂(cons₂(H1, T1), cons₂(H2, T2)) -> and₂(eqt₂(H1, H2), eqt₂(T1, T2))
eqt₂(cons₂(H1, T1), tuple₂(H2, T2)) -> F
eqt₂(cons₂(H1, T1), tuplenil₁(H2)) -> F
eqt₂(tuple₂(H1, T1), nil) -> F
eqt₂(tuple₂(H1, T1), a) -> F
eqt₂(tuple₂(H1, T1), excl) -> F
eqt₂(tuple₂(H1, T1), false) -> F
eqt₂(tuple₂(H1, T1), lock) -> F
eqt₂(tuple₂(H1, T1), locker) -> F
eqt₂(tuple₂(H1, T1), mcrlrecord) -> F
eqt₂(tuple₂(H1, T1), ok) -> F
eqt₂(tuple₂(H1, T1), pending) -> F
eqt₂(tuple₂(H1, T1), release) -> F
eqt₂(tuple₂(H1, T1), request) -> F
eqt₂(tuple₂(H1, T1), resource) -> F
eqt₂(tuple₂(H1, T1), tag) -> F
eqt₂(tuple₂(H1, T1), true) -> F
eqt₂(tuple₂(H1, T1), undefined) -> F
eqt₂(tuple₂(H1, T1), pid₁(N2)) -> F
eqt₂(tuple₂(H1, T1), int₁(N2)) -> F
eqt₂(tuple₂(H1, T1), cons₂(H2, T2)) -> F
eqt₂(tuple₂(H1, T1), tuple₂(H2, T2)) -> and₂(eqt₂(H1, H2), eqt₂(T1, T2))
eqt₂(tuple₂(H1, T1), tuplenil₁(H2)) -> F
eqt₂(tuplenil₁(H1), nil) -> F
eqt₂(tuplenil₁(H1), a) -> F
eqt₂(tuplenil₁(H1), excl) -> F
eqt₂(tuplenil₁(H1), false) -> F
eqt₂(tuplenil₁(H1), lock) -> F
eqt₂(tuplenil₁(H1), locker) -> F
eqt₂(tuplenil₁(H1), mcrlrecord) -> F
eqt₂(tuplenil₁(H1), ok) -> F
eqt₂(tuplenil₁(H1), pending) -> F
eqt₂(tuplenil₁(H1), release) -> F
eqt₂(tuplenil₁(H1), request) -> F
eqt₂(tuplenil₁(H1), resource) -> F
eqt₂(tuplenil₁(H1), tag) -> F
eqt₂(tuplenil₁(H1), true) -> F
eqt₂(tuplenil₁(H1), undefined) -> F
eqt₂(tuplenil₁(H1), pid₁(N2)) -> F
eqt₂(tuplenil₁(H1), int₁(N2)) -> F
eqt₂(tuplenil₁(H1), cons₂(H2, T2)) -> F
eqt₂(tuplenil₁(H1), tuple₂(H2, T2)) -> F
eqt₂(tuplenil₁(H1), tuplenil₁(H2)) -> eqt₂(H1, H2)
element₂(int₁(s₁(0)), tuplenil₁(T1)) -> T1
element₂(int₁(s₁(0)), tuple₂(T1, T2)) -> T1
element₂(int₁(s₁(s₁(N1))), tuple₂(T1, T2)) -> element₂(int₁(s₁(N1)), T2)
record_new₁(lock) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(undefined, tuple₂(nil, tuplenil₁(nil)))))
record_extract₃(tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2))))), lock, resource) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2)))))
record_update₄(tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2))))), lock, pending, NewF) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(NewF)))))
record_updates₃(Record, Name, nil) -> Record
record_updates₃(Record, Name, cons₂(tuple₂(Field, tuplenil₁(NewF)), Fields)) -> record_updates₃(record_update₄(Record, Name, Field, NewF), Name, Fields)
locker2_map_promote_pending₂(nil, Pending) -> nil
locker2_map_promote_pending₂(cons₂(Lock, Locks), Pending) -> cons₂(locker2_promote_pending₂(Lock, Pending), locker2_map_promote_pending₂(Locks, Pending))
locker2_map_claim_lock₃(nil, Resources, Client) -> nil
locker2_map_claim_lock₃(cons₂(Lock, Locks), Resources, Client) -> cons₂(locker2_claim_lock₃(Lock, Resources, Client), locker2_map_claim_lock₃(Locks, Resources, Client))
locker2_map_add_pending₃(nil, Resources, Client) -> nil
locker2_promote_pending₂(Lock, Client) -> case0₃(Client, Lock, record_extract₃(Lock, lock, pending))
case0₃(Client, Lock, cons₂(Client, Pendings)) -> record_updates₃(Lock, lock, cons₂(tuple₂(excl, tuplenil₁(Client)), cons₂(tuple₂(pending, tuplenil₁(Pendings)), nil)))
case0₃(Client, Lock, MCRLFree0) -> Lock
locker2_remove_pending₂(Lock, Client) -> record_updates₃(Lock, lock, cons₂(tuple₂(pending, tuplenil₁(subtract₂(record_extract₃(Lock, lock, pending), cons₂(Client, nil)))), nil))
locker2_add_pending₃(Lock, Resources, Client) -> case1₄(Client, Resources, Lock, member₂(record_extract₃(Lock, lock, resource), Resources))
case1₄(Client, Resources, Lock, true) -> record_updates₃(Lock, lock, cons₂(tuple₂(pending, tuplenil₁(append₂(record_extract₃(Lock, lock, pending), cons₂(Client, nil)))), nil))
case1₄(Client, Resources, Lock, false) -> Lock
locker2_release_lock₂(Lock, Client) -> case2₃(Client, Lock, gen_modtageq₂(Client, record_extract₃(Lock, lock, excl)))
case2₃(Client, Lock, true) -> record_updates₃(Lock, lock, cons₂(tuple₂(excllock, excl), nil))
case4₃(Client, Lock, MCRLFree1) -> false
locker2_obtainables₂(nil, Client) -> true
locker2_obtainables₂(cons₂(Lock, Locks), Client) -> case5₄(Client, Locks, Lock, member₂(Client, record_extract₃(Lock, lock, pending)))
case5₄(Client, Locks, Lock, true) -> andt₂(locker2_obtainable₂(Lock, Client), locker2_obtainables₂(Locks, Client))
case5₄(Client, Locks, Lock, false) -> locker2_obtainables₂(Locks, Client)
locker2_check_available₂(Resource, nil) -> false
locker2_check_available₂(Resource, cons₂(Lock, Locks)) -> case6₄(Locks, Lock, Resource, equal₂(Resource, record_extract₃(Lock, lock, resource)))
case6₄(Locks, Lock, Resource, true) -> andt₂(equal₂(record_extract₃(Lock, lock, excl), nil), equal₂(record_extract₃(Lock, lock, pending), nil))
case6₄(Locks, Lock, Resource, false) -> locker2_check_available₂(Resource, Locks)
locker2_check_availables₂(nil, Locks) -> true
locker2_check_availables₂(cons₂(Resource, Resources), Locks) -> andt₂(locker2_check_available₂(Resource, Locks), locker2_check_availables₂(Resources, Locks))
locker2_adduniq₂(nil, List) -> List
append₂(cons₂(Head, Tail), List) -> cons₂(Head, append₂(Tail, List))
subtract₂(List, nil) -> List
subtract₂(List, cons₂(Head, Tail)) -> subtract₂(delete₂(Head, List), Tail)
delete₂(E, nil) -> nil
delete₂(E, cons₂(Head, Tail)) -> case8₄(Tail, Head, E, equal₂(E, Head))
case8₄(Tail, Head, E, true) -> Tail
case8₄(Tail, Head, E, false) -> cons₂(Head, delete₂(E, Tail))
gen_tag₁(Pid) -> tuple₂(Pid, tuplenil₁(tag))
gen_modtageq₂(Client1, Client2) -> equal₂(Client1, Client2)
member₂(E, nil) -> false
member₂(E, cons₂(Head, Tail)) -> case9₄(Tail, Head, E, equal₂(E, Head))
case9₄(Tail, Head, E, true) -> true
case9₄(Tail, Head, E, false) -> member₂(E, Tail)
eqs₂(empty, empty) -> T
eqs₂(empty, stack₂(E2, S2)) -> F
eqs₂(stack₂(E1, S1), empty) -> F
eqs₂(stack₂(E1, S1), stack₂(E2, S2)) -> and₂(eqt₂(E1, E2), eqs₂(S1, S2))
pushs₂(E1, S1) -> stack₂(E1, S1)
pops₁(stack₂(E1, S1)) -> S1
tops₁(stack₂(E1, S1)) -> E1
istops₂(E1, empty) -> F
istops₂(E1, stack₂(E2, S1)) -> eqt₂(E1, E2)
eqc₂(nocalls, nocalls) -> T
eqc₂(nocalls, calls₃(E2, S2, CS2)) -> F
eqc₂(calls₃(E1, S1, CS1), nocalls) -> F
eqc₂(calls₃(E1, S1, CS1), calls₃(E2, S2, CS2)) -> and₂(eqt₂(E1, E2), and₂(eqs₂(S1, S2), eqc₂(CS1, CS2)))
push₃(E1, E2, nocalls) -> calls₃(E1, stack₂(E2, empty), nocalls)
push₃(E1, E2, calls₃(E3, S1, CS1)) -> push1₆(E1, E2, E3, S1, CS1, eqt₂(E1, E3))
push1₆(E1, E2, E3, S1, CS1, T) -> calls₃(E3, pushs₂(E2, S1), CS1)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

ELEMENT₂(int₁(s₁(s₁(N1))), tuple₂(T1, T2)) -> ELEMENT₂(int₁(s₁(N1)), T2)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial Order [17,21] with Interpretation:

POL( tuple₂(x₁, x₂) ) = x₁ + x₂ + 1

POL( s₁(x₁) ) = max{0, x₁ - 1}

POL( int₁(x₁) ) = 1

POL( ELEMENT₂(x₁, x₂) ) = x₁ + x₂ + 1

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

or₂(T, T) -> T
or₂(F, T) -> T
or₂(T, F) -> T
or₂(F, F) -> F
and₂(T, B) -> B
and₂(B, T) -> B
and₂(F, B) -> F
and₂(B, F) -> F
imp₂(T, B) -> B
imp₂(F, B) -> T
not₁(T) -> F
not₁(F) -> T
if₃(T, B1, B2) -> B1
if₃(F, B1, B2) -> B2
eq₂(T, T) -> T
eq₂(F, F) -> T
eq₂(T, F) -> F
eq₂(F, T) -> F
eqt₂(nil, undefined) -> F
eqt₂(nil, pid₁(N2)) -> F
eqt₂(nil, int₁(N2)) -> F
eqt₂(nil, cons₂(H2, T2)) -> F
eqt₂(nil, tuple₂(H2, T2)) -> F
eqt₂(nil, tuplenil₁(H2)) -> F
eqt₂(a, nil) -> F
eqt₂(a, a) -> T
eqt₂(a, excl) -> F
eqt₂(a, false) -> F
eqt₂(a, lock) -> F
eqt₂(a, locker) -> F
eqt₂(a, mcrlrecord) -> F
eqt₂(a, ok) -> F
eqt₂(a, pending) -> F
eqt₂(a, release) -> F
eqt₂(a, request) -> F
eqt₂(a, resource) -> F
eqt₂(a, tag) -> F
eqt₂(a, true) -> F
eqt₂(a, undefined) -> F
eqt₂(a, pid₁(N2)) -> F
eqt₂(a, int₁(N2)) -> F
eqt₂(a, cons₂(H2, T2)) -> F
eqt₂(a, tuple₂(H2, T2)) -> F
eqt₂(a, tuplenil₁(H2)) -> F
eqt₂(excl, nil) -> F
eqt₂(excl, a) -> F
eqt₂(excl, excl) -> T
eqt₂(excl, false) -> F
eqt₂(excl, lock) -> F
eqt₂(excl, locker) -> F
eqt₂(excl, mcrlrecord) -> F
eqt₂(excl, ok) -> F
eqt₂(excl, pending) -> F
eqt₂(excl, release) -> F
eqt₂(excl, request) -> F
eqt₂(excl, resource) -> F
eqt₂(excl, tag) -> F
eqt₂(excl, true) -> F
eqt₂(excl, undefined) -> F
eqt₂(excl, pid₁(N2)) -> F
eqt₂(excl, eqt₂(false, int₁(N2))) -> F
eqt₂(false, cons₂(H2, T2)) -> F
eqt₂(false, tuple₂(H2, T2)) -> F
eqt₂(false, tuplenil₁(H2)) -> F
eqt₂(lock, nil) -> F
eqt₂(lock, a) -> F
eqt₂(lock, excl) -> F
eqt₂(lock, false) -> F
eqt₂(lock, lock) -> T
eqt₂(lock, locker) -> F
eqt₂(lock, mcrlrecord) -> F
eqt₂(lock, ok) -> F
eqt₂(lock, pending) -> F
eqt₂(lock, release) -> F
eqt₂(lock, request) -> F
eqt₂(lock, resource) -> F
eqt₂(lock, tag) -> F
eqt₂(lock, true) -> F
eqt₂(lock, undefined) -> F
eqt₂(lock, pid₁(N2)) -> F
eqt₂(lock, int₁(N2)) -> F
eqt₂(lock, cons₂(H2, T2)) -> F
eqt₂(lock, tuple₂(H2, T2)) -> F
eqt₂(lock, tuplenil₁(H2)) -> F
eqt₂(locker, nil) -> F
eqt₂(locker, a) -> F
eqt₂(locker, excl) -> F
eqt₂(locker, false) -> F
eqt₂(locker, lock) -> F
eqt₂(locker, locker) -> T
eqt₂(locker, mcrlrecord) -> F
eqt₂(locker, ok) -> F
eqt₂(locker, pending) -> F
eqt₂(locker, release) -> F
eqt₂(locker, request) -> F
eqt₂(locker, resource) -> F
eqt₂(locker, tag) -> F
eqt₂(locker, true) -> F
eqt₂(locker, undefined) -> F
eqt₂(locker, pid₁(N2)) -> F
eqt₂(locker, int₁(N2)) -> F
eqt₂(locker, cons₂(H2, T2)) -> F
eqt₂(locker, tuple₂(H2, T2)) -> F
eqt₂(locker, tuplenil₁(H2)) -> F
eqt₂(mcrlrecord, nil) -> F
eqt₂(mcrlrecord, a) -> F
eqt₂(mcrlrecord, excl) -> F
eqt₂(mcrlrecord, false) -> F
eqt₂(mcrlrecord, lock) -> F
eqt₂(mcrlrecord, locker) -> F
eqt₂(mcrlrecord, mcrlrecord) -> T
eqt₂(mcrlrecord, ok) -> F
eqt₂(mcrlrecord, pending) -> F
eqt₂(mcrlrecord, release) -> F
eqt₂(mcrlrecord, request) -> F
eqt₂(mcrlrecord, resource) -> F
eqt₂(ok, resource) -> F
eqt₂(ok, tag) -> F
eqt₂(ok, true) -> F
eqt₂(ok, undefined) -> F
eqt₂(ok, pid₁(N2)) -> F
eqt₂(ok, int₁(N2)) -> F
eqt₂(ok, cons₂(H2, T2)) -> F
eqt₂(ok, tuple₂(H2, T2)) -> F
eqt₂(ok, tuplenil₁(H2)) -> F
eqt₂(pending, nil) -> F
eqt₂(pending, a) -> F
eqt₂(pending, excl) -> F
eqt₂(pending, false) -> F
eqt₂(pending, lock) -> F
eqt₂(pending, locker) -> F
eqt₂(pending, mcrlrecord) -> F
eqt₂(pending, ok) -> F
eqt₂(pending, pending) -> T
eqt₂(pending, release) -> F
eqt₂(pending, request) -> F
eqt₂(pending, resource) -> F
eqt₂(pending, tag) -> F
eqt₂(pending, true) -> F
eqt₂(pending, undefined) -> F
eqt₂(pending, pid₁(N2)) -> F
eqt₂(pending, int₁(N2)) -> F
eqt₂(pending, cons₂(H2, T2)) -> F
eqt₂(pending, tuple₂(H2, T2)) -> F
eqt₂(pending, tuplenil₁(H2)) -> F
eqt₂(release, nil) -> F
eqt₂(release, a) -> F
eqt₂(release, excl) -> F
eqt₂(release, false) -> F
eqt₂(release, lock) -> F
eqt₂(release, locker) -> F
eqt₂(release, mcrlrecord) -> F
eqt₂(release, ok) -> F
eqt₂(request, mcrlrecord) -> F
eqt₂(request, ok) -> F
eqt₂(request, pending) -> F
eqt₂(request, release) -> F
eqt₂(request, request) -> T
eqt₂(request, resource) -> F
eqt₂(request, tag) -> F
eqt₂(request, true) -> F
eqt₂(request, undefined) -> F
eqt₂(request, pid₁(N2)) -> F
eqt₂(request, int₁(N2)) -> F
eqt₂(request, cons₂(H2, T2)) -> F
eqt₂(request, tuple₂(H2, T2)) -> F
eqt₂(request, tuplenil₁(H2)) -> F
eqt₂(resource, nil) -> F
eqt₂(resource, a) -> F
eqt₂(resource, excl) -> F
eqt₂(resource, false) -> F
eqt₂(resource, lock) -> F
eqt₂(resource, locker) -> F
eqt₂(resource, mcrlrecord) -> F
eqt₂(resource, ok) -> F
eqt₂(resource, pending) -> F
eqt₂(resource, release) -> F
eqt₂(resource, request) -> F
eqt₂(resource, resource) -> T
eqt₂(resource, tag) -> F
eqt₂(resource, true) -> F
eqt₂(resource, undefined) -> F
eqt₂(resource, pid₁(N2)) -> F
eqt₂(resource, int₁(N2)) -> F
eqt₂(resource, cons₂(H2, T2)) -> F
eqt₂(resource, tuple₂(H2, T2)) -> F
eqt₂(resource, tuplenil₁(H2)) -> F
eqt₂(tag, nil) -> F
eqt₂(tag, a) -> F
eqt₂(tag, excl) -> F
eqt₂(tag, false) -> F
eqt₂(tag, lock) -> F
eqt₂(tag, locker) -> F
eqt₂(tag, mcrlrecord) -> F
eqt₂(tag, ok) -> F
eqt₂(tag, pending) -> F
eqt₂(tag, release) -> F
eqt₂(tag, request) -> F
eqt₂(tag, resource) -> F
eqt₂(tag, tag) -> T
eqt₂(tag, true) -> F
eqt₂(tag, undefined) -> F
eqt₂(tag, pid₁(N2)) -> F
eqt₂(tag, int₁(N2)) -> F
eqt₂(tag, cons₂(H2, T2)) -> F
eqt₂(tag, tuple₂(H2, T2)) -> F
eqt₂(tag, tuplenil₁(H2)) -> F
eqt₂(true, nil) -> F
eqt₂(true, a) -> F
eqt₂(true, excl) -> F
eqt₂(true, false) -> F
eqt₂(true, lock) -> F
eqt₂(true, locker) -> F
eqt₂(true, mcrlrecord) -> F
eqt₂(true, ok) -> F
eqt₂(true, pending) -> F
eqt₂(true, release) -> F
eqt₂(true, request) -> F
eqt₂(true, resource) -> F
eqt₂(true, tag) -> F
eqt₂(true, true) -> T
eqt₂(true, undefined) -> F
eqt₂(true, pid₁(N2)) -> F
eqt₂(true, int₁(N2)) -> F
eqt₂(true, cons₂(H2, T2)) -> F
eqt₂(true, tuple₂(H2, T2)) -> F
eqt₂(true, tuplenil₁(H2)) -> F
eqt₂(undefined, nil) -> F
eqt₂(undefined, a) -> F
eqt₂(undefined, tuplenil₁(H2)) -> F
eqt₂(pid₁(N1), nil) -> F
eqt₂(pid₁(N1), a) -> F
eqt₂(pid₁(N1), excl) -> F
eqt₂(pid₁(N1), false) -> F
eqt₂(pid₁(N1), lock) -> F
eqt₂(pid₁(N1), locker) -> F
eqt₂(pid₁(N1), mcrlrecord) -> F
eqt₂(pid₁(N1), ok) -> F
eqt₂(pid₁(N1), pending) -> F
eqt₂(pid₁(N1), release) -> F
eqt₂(pid₁(N1), request) -> F
eqt₂(pid₁(N1), resource) -> F
eqt₂(pid₁(N1), tag) -> F
eqt₂(pid₁(N1), true) -> F
eqt₂(pid₁(N1), undefined) -> F
eqt₂(pid₁(N1), pid₁(N2)) -> eqt₂(N1, N2)
eqt₂(pid₁(N1), int₁(N2)) -> F
eqt₂(pid₁(N1), cons₂(H2, T2)) -> F
eqt₂(pid₁(N1), tuple₂(H2, T2)) -> F
eqt₂(pid₁(N1), tuplenil₁(H2)) -> F
eqt₂(int₁(N1), nil) -> F
eqt₂(int₁(N1), a) -> F
eqt₂(int₁(N1), excl) -> F
eqt₂(int₁(N1), false) -> F
eqt₂(int₁(N1), lock) -> F
eqt₂(int₁(N1), locker) -> F
eqt₂(int₁(N1), mcrlrecord) -> F
eqt₂(int₁(N1), ok) -> F
eqt₂(int₁(N1), pending) -> F
eqt₂(int₁(N1), release) -> F
eqt₂(int₁(N1), request) -> F
eqt₂(int₁(N1), resource) -> F
eqt₂(int₁(N1), tag) -> F
eqt₂(int₁(N1), true) -> F
eqt₂(int₁(N1), undefined) -> F
eqt₂(cons₂(H1, T1), resource) -> F
eqt₂(cons₂(H1, T1), tag) -> F
eqt₂(cons₂(H1, T1), true) -> F
eqt₂(cons₂(H1, T1), undefined) -> F
eqt₂(cons₂(H1, T1), pid₁(N2)) -> F
eqt₂(cons₂(H1, T1), int₁(N2)) -> F
eqt₂(cons₂(H1, T1), cons₂(H2, T2)) -> and₂(eqt₂(H1, H2), eqt₂(T1, T2))
eqt₂(cons₂(H1, T1), tuple₂(H2, T2)) -> F
eqt₂(cons₂(H1, T1), tuplenil₁(H2)) -> F
eqt₂(tuple₂(H1, T1), nil) -> F
eqt₂(tuple₂(H1, T1), a) -> F
eqt₂(tuple₂(H1, T1), excl) -> F
eqt₂(tuple₂(H1, T1), false) -> F
eqt₂(tuple₂(H1, T1), lock) -> F
eqt₂(tuple₂(H1, T1), locker) -> F
eqt₂(tuple₂(H1, T1), mcrlrecord) -> F
eqt₂(tuple₂(H1, T1), ok) -> F
eqt₂(tuple₂(H1, T1), pending) -> F
eqt₂(tuple₂(H1, T1), release) -> F
eqt₂(tuple₂(H1, T1), request) -> F
eqt₂(tuple₂(H1, T1), resource) -> F
eqt₂(tuple₂(H1, T1), tag) -> F
eqt₂(tuple₂(H1, T1), true) -> F
eqt₂(tuple₂(H1, T1), undefined) -> F
eqt₂(tuple₂(H1, T1), pid₁(N2)) -> F
eqt₂(tuple₂(H1, T1), int₁(N2)) -> F
eqt₂(tuple₂(H1, T1), cons₂(H2, T2)) -> F
eqt₂(tuple₂(H1, T1), tuple₂(H2, T2)) -> and₂(eqt₂(H1, H2), eqt₂(T1, T2))
eqt₂(tuple₂(H1, T1), tuplenil₁(H2)) -> F
eqt₂(tuplenil₁(H1), nil) -> F
eqt₂(tuplenil₁(H1), a) -> F
eqt₂(tuplenil₁(H1), excl) -> F
eqt₂(tuplenil₁(H1), false) -> F
eqt₂(tuplenil₁(H1), lock) -> F
eqt₂(tuplenil₁(H1), locker) -> F
eqt₂(tuplenil₁(H1), mcrlrecord) -> F
eqt₂(tuplenil₁(H1), ok) -> F
eqt₂(tuplenil₁(H1), pending) -> F
eqt₂(tuplenil₁(H1), release) -> F
eqt₂(tuplenil₁(H1), request) -> F
eqt₂(tuplenil₁(H1), resource) -> F
eqt₂(tuplenil₁(H1), tag) -> F
eqt₂(tuplenil₁(H1), true) -> F
eqt₂(tuplenil₁(H1), undefined) -> F
eqt₂(tuplenil₁(H1), pid₁(N2)) -> F
eqt₂(tuplenil₁(H1), int₁(N2)) -> F
eqt₂(tuplenil₁(H1), cons₂(H2, T2)) -> F
eqt₂(tuplenil₁(H1), tuple₂(H2, T2)) -> F
eqt₂(tuplenil₁(H1), tuplenil₁(H2)) -> eqt₂(H1, H2)
element₂(int₁(s₁(0)), tuplenil₁(T1)) -> T1
element₂(int₁(s₁(0)), tuple₂(T1, T2)) -> T1
element₂(int₁(s₁(s₁(N1))), tuple₂(T1, T2)) -> element₂(int₁(s₁(N1)), T2)
record_new₁(lock) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(undefined, tuple₂(nil, tuplenil₁(nil)))))
record_extract₃(tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2))))), lock, resource) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2)))))
record_update₄(tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2))))), lock, pending, NewF) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(NewF)))))
record_updates₃(Record, Name, nil) -> Record
record_updates₃(Record, Name, cons₂(tuple₂(Field, tuplenil₁(NewF)), Fields)) -> record_updates₃(record_update₄(Record, Name, Field, NewF), Name, Fields)
locker2_map_promote_pending₂(nil, Pending) -> nil
locker2_map_promote_pending₂(cons₂(Lock, Locks), Pending) -> cons₂(locker2_promote_pending₂(Lock, Pending), locker2_map_promote_pending₂(Locks, Pending))
locker2_map_claim_lock₃(nil, Resources, Client) -> nil
locker2_map_claim_lock₃(cons₂(Lock, Locks), Resources, Client) -> cons₂(locker2_claim_lock₃(Lock, Resources, Client), locker2_map_claim_lock₃(Locks, Resources, Client))
locker2_map_add_pending₃(nil, Resources, Client) -> nil
locker2_promote_pending₂(Lock, Client) -> case0₃(Client, Lock, record_extract₃(Lock, lock, pending))
case0₃(Client, Lock, cons₂(Client, Pendings)) -> record_updates₃(Lock, lock, cons₂(tuple₂(excl, tuplenil₁(Client)), cons₂(tuple₂(pending, tuplenil₁(Pendings)), nil)))
case0₃(Client, Lock, MCRLFree0) -> Lock
locker2_remove_pending₂(Lock, Client) -> record_updates₃(Lock, lock, cons₂(tuple₂(pending, tuplenil₁(subtract₂(record_extract₃(Lock, lock, pending), cons₂(Client, nil)))), nil))
locker2_add_pending₃(Lock, Resources, Client) -> case1₄(Client, Resources, Lock, member₂(record_extract₃(Lock, lock, resource), Resources))
case1₄(Client, Resources, Lock, true) -> record_updates₃(Lock, lock, cons₂(tuple₂(pending, tuplenil₁(append₂(record_extract₃(Lock, lock, pending), cons₂(Client, nil)))), nil))
case1₄(Client, Resources, Lock, false) -> Lock
locker2_release_lock₂(Lock, Client) -> case2₃(Client, Lock, gen_modtageq₂(Client, record_extract₃(Lock, lock, excl)))
case2₃(Client, Lock, true) -> record_updates₃(Lock, lock, cons₂(tuple₂(excllock, excl), nil))
case4₃(Client, Lock, MCRLFree1) -> false
locker2_obtainables₂(nil, Client) -> true
locker2_obtainables₂(cons₂(Lock, Locks), Client) -> case5₄(Client, Locks, Lock, member₂(Client, record_extract₃(Lock, lock, pending)))
case5₄(Client, Locks, Lock, true) -> andt₂(locker2_obtainable₂(Lock, Client), locker2_obtainables₂(Locks, Client))
case5₄(Client, Locks, Lock, false) -> locker2_obtainables₂(Locks, Client)
locker2_check_available₂(Resource, nil) -> false
locker2_check_available₂(Resource, cons₂(Lock, Locks)) -> case6₄(Locks, Lock, Resource, equal₂(Resource, record_extract₃(Lock, lock, resource)))
case6₄(Locks, Lock, Resource, true) -> andt₂(equal₂(record_extract₃(Lock, lock, excl), nil), equal₂(record_extract₃(Lock, lock, pending), nil))
case6₄(Locks, Lock, Resource, false) -> locker2_check_available₂(Resource, Locks)
locker2_check_availables₂(nil, Locks) -> true
locker2_check_availables₂(cons₂(Resource, Resources), Locks) -> andt₂(locker2_check_available₂(Resource, Locks), locker2_check_availables₂(Resources, Locks))
locker2_adduniq₂(nil, List) -> List
append₂(cons₂(Head, Tail), List) -> cons₂(Head, append₂(Tail, List))
subtract₂(List, nil) -> List
subtract₂(List, cons₂(Head, Tail)) -> subtract₂(delete₂(Head, List), Tail)
delete₂(E, nil) -> nil
delete₂(E, cons₂(Head, Tail)) -> case8₄(Tail, Head, E, equal₂(E, Head))
case8₄(Tail, Head, E, true) -> Tail
case8₄(Tail, Head, E, false) -> cons₂(Head, delete₂(E, Tail))
gen_tag₁(Pid) -> tuple₂(Pid, tuplenil₁(tag))
gen_modtageq₂(Client1, Client2) -> equal₂(Client1, Client2)
member₂(E, nil) -> false
member₂(E, cons₂(Head, Tail)) -> case9₄(Tail, Head, E, equal₂(E, Head))
case9₄(Tail, Head, E, true) -> true
case9₄(Tail, Head, E, false) -> member₂(E, Tail)
eqs₂(empty, empty) -> T
eqs₂(empty, stack₂(E2, S2)) -> F
eqs₂(stack₂(E1, S1), empty) -> F
eqs₂(stack₂(E1, S1), stack₂(E2, S2)) -> and₂(eqt₂(E1, E2), eqs₂(S1, S2))
pushs₂(E1, S1) -> stack₂(E1, S1)
pops₁(stack₂(E1, S1)) -> S1
tops₁(stack₂(E1, S1)) -> E1
istops₂(E1, empty) -> F
istops₂(E1, stack₂(E2, S1)) -> eqt₂(E1, E2)
eqc₂(nocalls, nocalls) -> T
eqc₂(nocalls, calls₃(E2, S2, CS2)) -> F
eqc₂(calls₃(E1, S1, CS1), nocalls) -> F
eqc₂(calls₃(E1, S1, CS1), calls₃(E2, S2, CS2)) -> and₂(eqt₂(E1, E2), and₂(eqs₂(S1, S2), eqc₂(CS1, CS2)))
push₃(E1, E2, nocalls) -> calls₃(E1, stack₂(E2, empty), nocalls)
push₃(E1, E2, calls₃(E3, S1, CS1)) -> push1₆(E1, E2, E3, S1, CS1, eqt₂(E1, E3))
push1₆(E1, E2, E3, S1, CS1, T) -> calls₃(E3, pushs₂(E2, S1), CS1)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

EQT₂(tuple₂(H1, T1), tuple₂(H2, T2)) -> EQT₂(H1, H2)
EQT₂(tuplenil₁(H1), tuplenil₁(H2)) -> EQT₂(H1, H2)
EQT₂(pid₁(N1), pid₁(N2)) -> EQT₂(N1, N2)
EQT₂(cons₂(H1, T1), cons₂(H2, T2)) -> EQT₂(T1, T2)
EQT₂(tuple₂(H1, T1), tuple₂(H2, T2)) -> EQT₂(T1, T2)
EQT₂(cons₂(H1, T1), cons₂(H2, T2)) -> EQT₂(H1, H2)

The TRS R consists of the following rules:

or₂(T, T) -> T
or₂(F, T) -> T
or₂(T, F) -> T
or₂(F, F) -> F
and₂(T, B) -> B
and₂(B, T) -> B
and₂(F, B) -> F
and₂(B, F) -> F
imp₂(T, B) -> B
imp₂(F, B) -> T
not₁(T) -> F
not₁(F) -> T
if₃(T, B1, B2) -> B1
if₃(F, B1, B2) -> B2
eq₂(T, T) -> T
eq₂(F, F) -> T
eq₂(T, F) -> F
eq₂(F, T) -> F
eqt₂(nil, undefined) -> F
eqt₂(nil, pid₁(N2)) -> F
eqt₂(nil, int₁(N2)) -> F
eqt₂(nil, cons₂(H2, T2)) -> F
eqt₂(nil, tuple₂(H2, T2)) -> F
eqt₂(nil, tuplenil₁(H2)) -> F
eqt₂(a, nil) -> F
eqt₂(a, a) -> T
eqt₂(a, excl) -> F
eqt₂(a, false) -> F
eqt₂(a, lock) -> F
eqt₂(a, locker) -> F
eqt₂(a, mcrlrecord) -> F
eqt₂(a, ok) -> F
eqt₂(a, pending) -> F
eqt₂(a, release) -> F
eqt₂(a, request) -> F
eqt₂(a, resource) -> F
eqt₂(a, tag) -> F
eqt₂(a, true) -> F
eqt₂(a, undefined) -> F
eqt₂(a, pid₁(N2)) -> F
eqt₂(a, int₁(N2)) -> F
eqt₂(a, cons₂(H2, T2)) -> F
eqt₂(a, tuple₂(H2, T2)) -> F
eqt₂(a, tuplenil₁(H2)) -> F
eqt₂(excl, nil) -> F
eqt₂(excl, a) -> F
eqt₂(excl, excl) -> T
eqt₂(excl, false) -> F
eqt₂(excl, lock) -> F
eqt₂(excl, locker) -> F
eqt₂(excl, mcrlrecord) -> F
eqt₂(excl, ok) -> F
eqt₂(excl, pending) -> F
eqt₂(excl, release) -> F
eqt₂(excl, request) -> F
eqt₂(excl, resource) -> F
eqt₂(excl, tag) -> F
eqt₂(excl, true) -> F
eqt₂(excl, undefined) -> F
eqt₂(excl, pid₁(N2)) -> F
eqt₂(excl, eqt₂(false, int₁(N2))) -> F
eqt₂(false, cons₂(H2, T2)) -> F
eqt₂(false, tuple₂(H2, T2)) -> F
eqt₂(false, tuplenil₁(H2)) -> F
eqt₂(lock, nil) -> F
eqt₂(lock, a) -> F
eqt₂(lock, excl) -> F
eqt₂(lock, false) -> F
eqt₂(lock, lock) -> T
eqt₂(lock, locker) -> F
eqt₂(lock, mcrlrecord) -> F
eqt₂(lock, ok) -> F
eqt₂(lock, pending) -> F
eqt₂(lock, release) -> F
eqt₂(lock, request) -> F
eqt₂(lock, resource) -> F
eqt₂(lock, tag) -> F
eqt₂(lock, true) -> F
eqt₂(lock, undefined) -> F
eqt₂(lock, pid₁(N2)) -> F
eqt₂(lock, int₁(N2)) -> F
eqt₂(lock, cons₂(H2, T2)) -> F
eqt₂(lock, tuple₂(H2, T2)) -> F
eqt₂(lock, tuplenil₁(H2)) -> F
eqt₂(locker, nil) -> F
eqt₂(locker, a) -> F
eqt₂(locker, excl) -> F
eqt₂(locker, false) -> F
eqt₂(locker, lock) -> F
eqt₂(locker, locker) -> T
eqt₂(locker, mcrlrecord) -> F
eqt₂(locker, ok) -> F
eqt₂(locker, pending) -> F
eqt₂(locker, release) -> F
eqt₂(locker, request) -> F
eqt₂(locker, resource) -> F
eqt₂(locker, tag) -> F
eqt₂(locker, true) -> F
eqt₂(locker, undefined) -> F
eqt₂(locker, pid₁(N2)) -> F
eqt₂(locker, int₁(N2)) -> F
eqt₂(locker, cons₂(H2, T2)) -> F
eqt₂(locker, tuple₂(H2, T2)) -> F
eqt₂(locker, tuplenil₁(H2)) -> F
eqt₂(mcrlrecord, nil) -> F
eqt₂(mcrlrecord, a) -> F
eqt₂(mcrlrecord, excl) -> F
eqt₂(mcrlrecord, false) -> F
eqt₂(mcrlrecord, lock) -> F
eqt₂(mcrlrecord, locker) -> F
eqt₂(mcrlrecord, mcrlrecord) -> T
eqt₂(mcrlrecord, ok) -> F
eqt₂(mcrlrecord, pending) -> F
eqt₂(mcrlrecord, release) -> F
eqt₂(mcrlrecord, request) -> F
eqt₂(mcrlrecord, resource) -> F
eqt₂(ok, resource) -> F
eqt₂(ok, tag) -> F
eqt₂(ok, true) -> F
eqt₂(ok, undefined) -> F
eqt₂(ok, pid₁(N2)) -> F
eqt₂(ok, int₁(N2)) -> F
eqt₂(ok, cons₂(H2, T2)) -> F
eqt₂(ok, tuple₂(H2, T2)) -> F
eqt₂(ok, tuplenil₁(H2)) -> F
eqt₂(pending, nil) -> F
eqt₂(pending, a) -> F
eqt₂(pending, excl) -> F
eqt₂(pending, false) -> F
eqt₂(pending, lock) -> F
eqt₂(pending, locker) -> F
eqt₂(pending, mcrlrecord) -> F
eqt₂(pending, ok) -> F
eqt₂(pending, pending) -> T
eqt₂(pending, release) -> F
eqt₂(pending, request) -> F
eqt₂(pending, resource) -> F
eqt₂(pending, tag) -> F
eqt₂(pending, true) -> F
eqt₂(pending, undefined) -> F
eqt₂(pending, pid₁(N2)) -> F
eqt₂(pending, int₁(N2)) -> F
eqt₂(pending, cons₂(H2, T2)) -> F
eqt₂(pending, tuple₂(H2, T2)) -> F
eqt₂(pending, tuplenil₁(H2)) -> F
eqt₂(release, nil) -> F
eqt₂(release, a) -> F
eqt₂(release, excl) -> F
eqt₂(release, false) -> F
eqt₂(release, lock) -> F
eqt₂(release, locker) -> F
eqt₂(release, mcrlrecord) -> F
eqt₂(release, ok) -> F
eqt₂(request, mcrlrecord) -> F
eqt₂(request, ok) -> F
eqt₂(request, pending) -> F
eqt₂(request, release) -> F
eqt₂(request, request) -> T
eqt₂(request, resource) -> F
eqt₂(request, tag) -> F
eqt₂(request, true) -> F
eqt₂(request, undefined) -> F
eqt₂(request, pid₁(N2)) -> F
eqt₂(request, int₁(N2)) -> F
eqt₂(request, cons₂(H2, T2)) -> F
eqt₂(request, tuple₂(H2, T2)) -> F
eqt₂(request, tuplenil₁(H2)) -> F
eqt₂(resource, nil) -> F
eqt₂(resource, a) -> F
eqt₂(resource, excl) -> F
eqt₂(resource, false) -> F
eqt₂(resource, lock) -> F
eqt₂(resource, locker) -> F
eqt₂(resource, mcrlrecord) -> F
eqt₂(resource, ok) -> F
eqt₂(resource, pending) -> F
eqt₂(resource, release) -> F
eqt₂(resource, request) -> F
eqt₂(resource, resource) -> T
eqt₂(resource, tag) -> F
eqt₂(resource, true) -> F
eqt₂(resource, undefined) -> F
eqt₂(resource, pid₁(N2)) -> F
eqt₂(resource, int₁(N2)) -> F
eqt₂(resource, cons₂(H2, T2)) -> F
eqt₂(resource, tuple₂(H2, T2)) -> F
eqt₂(resource, tuplenil₁(H2)) -> F
eqt₂(tag, nil) -> F
eqt₂(tag, a) -> F
eqt₂(tag, excl) -> F
eqt₂(tag, false) -> F
eqt₂(tag, lock) -> F
eqt₂(tag, locker) -> F
eqt₂(tag, mcrlrecord) -> F
eqt₂(tag, ok) -> F
eqt₂(tag, pending) -> F
eqt₂(tag, release) -> F
eqt₂(tag, request) -> F
eqt₂(tag, resource) -> F
eqt₂(tag, tag) -> T
eqt₂(tag, true) -> F
eqt₂(tag, undefined) -> F
eqt₂(tag, pid₁(N2)) -> F
eqt₂(tag, int₁(N2)) -> F
eqt₂(tag, cons₂(H2, T2)) -> F
eqt₂(tag, tuple₂(H2, T2)) -> F
eqt₂(tag, tuplenil₁(H2)) -> F
eqt₂(true, nil) -> F
eqt₂(true, a) -> F
eqt₂(true, excl) -> F
eqt₂(true, false) -> F
eqt₂(true, lock) -> F
eqt₂(true, locker) -> F
eqt₂(true, mcrlrecord) -> F
eqt₂(true, ok) -> F
eqt₂(true, pending) -> F
eqt₂(true, release) -> F
eqt₂(true, request) -> F
eqt₂(true, resource) -> F
eqt₂(true, tag) -> F
eqt₂(true, true) -> T
eqt₂(true, undefined) -> F
eqt₂(true, pid₁(N2)) -> F
eqt₂(true, int₁(N2)) -> F
eqt₂(true, cons₂(H2, T2)) -> F
eqt₂(true, tuple₂(H2, T2)) -> F
eqt₂(true, tuplenil₁(H2)) -> F
eqt₂(undefined, nil) -> F
eqt₂(undefined, a) -> F
eqt₂(undefined, tuplenil₁(H2)) -> F
eqt₂(pid₁(N1), nil) -> F
eqt₂(pid₁(N1), a) -> F
eqt₂(pid₁(N1), excl) -> F
eqt₂(pid₁(N1), false) -> F
eqt₂(pid₁(N1), lock) -> F
eqt₂(pid₁(N1), locker) -> F
eqt₂(pid₁(N1), mcrlrecord) -> F
eqt₂(pid₁(N1), ok) -> F
eqt₂(pid₁(N1), pending) -> F
eqt₂(pid₁(N1), release) -> F
eqt₂(pid₁(N1), request) -> F
eqt₂(pid₁(N1), resource) -> F
eqt₂(pid₁(N1), tag) -> F
eqt₂(pid₁(N1), true) -> F
eqt₂(pid₁(N1), undefined) -> F
eqt₂(pid₁(N1), pid₁(N2)) -> eqt₂(N1, N2)
eqt₂(pid₁(N1), int₁(N2)) -> F
eqt₂(pid₁(N1), cons₂(H2, T2)) -> F
eqt₂(pid₁(N1), tuple₂(H2, T2)) -> F
eqt₂(pid₁(N1), tuplenil₁(H2)) -> F
eqt₂(int₁(N1), nil) -> F
eqt₂(int₁(N1), a) -> F
eqt₂(int₁(N1), excl) -> F
eqt₂(int₁(N1), false) -> F
eqt₂(int₁(N1), lock) -> F
eqt₂(int₁(N1), locker) -> F
eqt₂(int₁(N1), mcrlrecord) -> F
eqt₂(int₁(N1), ok) -> F
eqt₂(int₁(N1), pending) -> F
eqt₂(int₁(N1), release) -> F
eqt₂(int₁(N1), request) -> F
eqt₂(int₁(N1), resource) -> F
eqt₂(int₁(N1), tag) -> F
eqt₂(int₁(N1), true) -> F
eqt₂(int₁(N1), undefined) -> F
eqt₂(cons₂(H1, T1), resource) -> F
eqt₂(cons₂(H1, T1), tag) -> F
eqt₂(cons₂(H1, T1), true) -> F
eqt₂(cons₂(H1, T1), undefined) -> F
eqt₂(cons₂(H1, T1), pid₁(N2)) -> F
eqt₂(cons₂(H1, T1), int₁(N2)) -> F
eqt₂(cons₂(H1, T1), cons₂(H2, T2)) -> and₂(eqt₂(H1, H2), eqt₂(T1, T2))
eqt₂(cons₂(H1, T1), tuple₂(H2, T2)) -> F
eqt₂(cons₂(H1, T1), tuplenil₁(H2)) -> F
eqt₂(tuple₂(H1, T1), nil) -> F
eqt₂(tuple₂(H1, T1), a) -> F
eqt₂(tuple₂(H1, T1), excl) -> F
eqt₂(tuple₂(H1, T1), false) -> F
eqt₂(tuple₂(H1, T1), lock) -> F
eqt₂(tuple₂(H1, T1), locker) -> F
eqt₂(tuple₂(H1, T1), mcrlrecord) -> F
eqt₂(tuple₂(H1, T1), ok) -> F
eqt₂(tuple₂(H1, T1), pending) -> F
eqt₂(tuple₂(H1, T1), release) -> F
eqt₂(tuple₂(H1, T1), request) -> F
eqt₂(tuple₂(H1, T1), resource) -> F
eqt₂(tuple₂(H1, T1), tag) -> F
eqt₂(tuple₂(H1, T1), true) -> F
eqt₂(tuple₂(H1, T1), undefined) -> F
eqt₂(tuple₂(H1, T1), pid₁(N2)) -> F
eqt₂(tuple₂(H1, T1), int₁(N2)) -> F
eqt₂(tuple₂(H1, T1), cons₂(H2, T2)) -> F
eqt₂(tuple₂(H1, T1), tuple₂(H2, T2)) -> and₂(eqt₂(H1, H2), eqt₂(T1, T2))
eqt₂(tuple₂(H1, T1), tuplenil₁(H2)) -> F
eqt₂(tuplenil₁(H1), nil) -> F
eqt₂(tuplenil₁(H1), a) -> F
eqt₂(tuplenil₁(H1), excl) -> F
eqt₂(tuplenil₁(H1), false) -> F
eqt₂(tuplenil₁(H1), lock) -> F
eqt₂(tuplenil₁(H1), locker) -> F
eqt₂(tuplenil₁(H1), mcrlrecord) -> F
eqt₂(tuplenil₁(H1), ok) -> F
eqt₂(tuplenil₁(H1), pending) -> F
eqt₂(tuplenil₁(H1), release) -> F
eqt₂(tuplenil₁(H1), request) -> F
eqt₂(tuplenil₁(H1), resource) -> F
eqt₂(tuplenil₁(H1), tag) -> F
eqt₂(tuplenil₁(H1), true) -> F
eqt₂(tuplenil₁(H1), undefined) -> F
eqt₂(tuplenil₁(H1), pid₁(N2)) -> F
eqt₂(tuplenil₁(H1), int₁(N2)) -> F
eqt₂(tuplenil₁(H1), cons₂(H2, T2)) -> F
eqt₂(tuplenil₁(H1), tuple₂(H2, T2)) -> F
eqt₂(tuplenil₁(H1), tuplenil₁(H2)) -> eqt₂(H1, H2)
element₂(int₁(s₁(0)), tuplenil₁(T1)) -> T1
element₂(int₁(s₁(0)), tuple₂(T1, T2)) -> T1
element₂(int₁(s₁(s₁(N1))), tuple₂(T1, T2)) -> element₂(int₁(s₁(N1)), T2)
record_new₁(lock) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(undefined, tuple₂(nil, tuplenil₁(nil)))))
record_extract₃(tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2))))), lock, resource) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2)))))
record_update₄(tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2))))), lock, pending, NewF) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(NewF)))))
record_updates₃(Record, Name, nil) -> Record
record_updates₃(Record, Name, cons₂(tuple₂(Field, tuplenil₁(NewF)), Fields)) -> record_updates₃(record_update₄(Record, Name, Field, NewF), Name, Fields)
locker2_map_promote_pending₂(nil, Pending) -> nil
locker2_map_promote_pending₂(cons₂(Lock, Locks), Pending) -> cons₂(locker2_promote_pending₂(Lock, Pending), locker2_map_promote_pending₂(Locks, Pending))
locker2_map_claim_lock₃(nil, Resources, Client) -> nil
locker2_map_claim_lock₃(cons₂(Lock, Locks), Resources, Client) -> cons₂(locker2_claim_lock₃(Lock, Resources, Client), locker2_map_claim_lock₃(Locks, Resources, Client))
locker2_map_add_pending₃(nil, Resources, Client) -> nil
locker2_promote_pending₂(Lock, Client) -> case0₃(Client, Lock, record_extract₃(Lock, lock, pending))
case0₃(Client, Lock, cons₂(Client, Pendings)) -> record_updates₃(Lock, lock, cons₂(tuple₂(excl, tuplenil₁(Client)), cons₂(tuple₂(pending, tuplenil₁(Pendings)), nil)))
case0₃(Client, Lock, MCRLFree0) -> Lock
locker2_remove_pending₂(Lock, Client) -> record_updates₃(Lock, lock, cons₂(tuple₂(pending, tuplenil₁(subtract₂(record_extract₃(Lock, lock, pending), cons₂(Client, nil)))), nil))
locker2_add_pending₃(Lock, Resources, Client) -> case1₄(Client, Resources, Lock, member₂(record_extract₃(Lock, lock, resource), Resources))
case1₄(Client, Resources, Lock, true) -> record_updates₃(Lock, lock, cons₂(tuple₂(pending, tuplenil₁(append₂(record_extract₃(Lock, lock, pending), cons₂(Client, nil)))), nil))
case1₄(Client, Resources, Lock, false) -> Lock
locker2_release_lock₂(Lock, Client) -> case2₃(Client, Lock, gen_modtageq₂(Client, record_extract₃(Lock, lock, excl)))
case2₃(Client, Lock, true) -> record_updates₃(Lock, lock, cons₂(tuple₂(excllock, excl), nil))
case4₃(Client, Lock, MCRLFree1) -> false
locker2_obtainables₂(nil, Client) -> true
locker2_obtainables₂(cons₂(Lock, Locks), Client) -> case5₄(Client, Locks, Lock, member₂(Client, record_extract₃(Lock, lock, pending)))
case5₄(Client, Locks, Lock, true) -> andt₂(locker2_obtainable₂(Lock, Client), locker2_obtainables₂(Locks, Client))
case5₄(Client, Locks, Lock, false) -> locker2_obtainables₂(Locks, Client)
locker2_check_available₂(Resource, nil) -> false
locker2_check_available₂(Resource, cons₂(Lock, Locks)) -> case6₄(Locks, Lock, Resource, equal₂(Resource, record_extract₃(Lock, lock, resource)))
case6₄(Locks, Lock, Resource, true) -> andt₂(equal₂(record_extract₃(Lock, lock, excl), nil), equal₂(record_extract₃(Lock, lock, pending), nil))
case6₄(Locks, Lock, Resource, false) -> locker2_check_available₂(Resource, Locks)
locker2_check_availables₂(nil, Locks) -> true
locker2_check_availables₂(cons₂(Resource, Resources), Locks) -> andt₂(locker2_check_available₂(Resource, Locks), locker2_check_availables₂(Resources, Locks))
locker2_adduniq₂(nil, List) -> List
append₂(cons₂(Head, Tail), List) -> cons₂(Head, append₂(Tail, List))
subtract₂(List, nil) -> List
subtract₂(List, cons₂(Head, Tail)) -> subtract₂(delete₂(Head, List), Tail)
delete₂(E, nil) -> nil
delete₂(E, cons₂(Head, Tail)) -> case8₄(Tail, Head, E, equal₂(E, Head))
case8₄(Tail, Head, E, true) -> Tail
case8₄(Tail, Head, E, false) -> cons₂(Head, delete₂(E, Tail))
gen_tag₁(Pid) -> tuple₂(Pid, tuplenil₁(tag))
gen_modtageq₂(Client1, Client2) -> equal₂(Client1, Client2)
member₂(E, nil) -> false
member₂(E, cons₂(Head, Tail)) -> case9₄(Tail, Head, E, equal₂(E, Head))
case9₄(Tail, Head, E, true) -> true
case9₄(Tail, Head, E, false) -> member₂(E, Tail)
eqs₂(empty, empty) -> T
eqs₂(empty, stack₂(E2, S2)) -> F
eqs₂(stack₂(E1, S1), empty) -> F
eqs₂(stack₂(E1, S1), stack₂(E2, S2)) -> and₂(eqt₂(E1, E2), eqs₂(S1, S2))
pushs₂(E1, S1) -> stack₂(E1, S1)
pops₁(stack₂(E1, S1)) -> S1
tops₁(stack₂(E1, S1)) -> E1
istops₂(E1, empty) -> F
istops₂(E1, stack₂(E2, S1)) -> eqt₂(E1, E2)
eqc₂(nocalls, nocalls) -> T
eqc₂(nocalls, calls₃(E2, S2, CS2)) -> F
eqc₂(calls₃(E1, S1, CS1), nocalls) -> F
eqc₂(calls₃(E1, S1, CS1), calls₃(E2, S2, CS2)) -> and₂(eqt₂(E1, E2), and₂(eqs₂(S1, S2), eqc₂(CS1, CS2)))
push₃(E1, E2, nocalls) -> calls₃(E1, stack₂(E2, empty), nocalls)
push₃(E1, E2, calls₃(E3, S1, CS1)) -> push1₆(E1, E2, E3, S1, CS1, eqt₂(E1, E3))
push1₆(E1, E2, E3, S1, CS1, T) -> calls₃(E3, pushs₂(E2, S1), CS1)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

EQT₂(tuple₂(H1, T1), tuple₂(H2, T2)) -> EQT₂(H1, H2)
EQT₂(pid₁(N1), pid₁(N2)) -> EQT₂(N1, N2)
EQT₂(cons₂(H1, T1), cons₂(H2, T2)) -> EQT₂(T1, T2)
EQT₂(tuple₂(H1, T1), tuple₂(H2, T2)) -> EQT₂(T1, T2)
EQT₂(cons₂(H1, T1), cons₂(H2, T2)) -> EQT₂(H1, H2)

The remaining pairs can at least be oriented weakly.

EQT₂(tuplenil₁(H1), tuplenil₁(H2)) -> EQT₂(H1, H2)

Used ordering: Polynomial Order [17,21] with Interpretation:

POL( tuple₂(x₁, x₂) ) = x₁ + x₂ + 1

POL( tuplenil₁(x₁) ) = x₁

POL( cons₂(x₁, x₂) ) = x₁ + x₂ + 1

POL( pid₁(x₁) ) = x₁ + 1

POL( EQT₂(x₁, x₂) ) = x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

EQT₂(tuplenil₁(H1), tuplenil₁(H2)) -> EQT₂(H1, H2)

The TRS R consists of the following rules:

or₂(T, T) -> T
or₂(F, T) -> T
or₂(T, F) -> T
or₂(F, F) -> F
and₂(T, B) -> B
and₂(B, T) -> B
and₂(F, B) -> F
and₂(B, F) -> F
imp₂(T, B) -> B
imp₂(F, B) -> T
not₁(T) -> F
not₁(F) -> T
if₃(T, B1, B2) -> B1
if₃(F, B1, B2) -> B2
eq₂(T, T) -> T
eq₂(F, F) -> T
eq₂(T, F) -> F
eq₂(F, T) -> F
eqt₂(nil, undefined) -> F
eqt₂(nil, pid₁(N2)) -> F
eqt₂(nil, int₁(N2)) -> F
eqt₂(nil, cons₂(H2, T2)) -> F
eqt₂(nil, tuple₂(H2, T2)) -> F
eqt₂(nil, tuplenil₁(H2)) -> F
eqt₂(a, nil) -> F
eqt₂(a, a) -> T
eqt₂(a, excl) -> F
eqt₂(a, false) -> F
eqt₂(a, lock) -> F
eqt₂(a, locker) -> F
eqt₂(a, mcrlrecord) -> F
eqt₂(a, ok) -> F
eqt₂(a, pending) -> F
eqt₂(a, release) -> F
eqt₂(a, request) -> F
eqt₂(a, resource) -> F
eqt₂(a, tag) -> F
eqt₂(a, true) -> F
eqt₂(a, undefined) -> F
eqt₂(a, pid₁(N2)) -> F
eqt₂(a, int₁(N2)) -> F
eqt₂(a, cons₂(H2, T2)) -> F
eqt₂(a, tuple₂(H2, T2)) -> F
eqt₂(a, tuplenil₁(H2)) -> F
eqt₂(excl, nil) -> F
eqt₂(excl, a) -> F
eqt₂(excl, excl) -> T
eqt₂(excl, false) -> F
eqt₂(excl, lock) -> F
eqt₂(excl, locker) -> F
eqt₂(excl, mcrlrecord) -> F
eqt₂(excl, ok) -> F
eqt₂(excl, pending) -> F
eqt₂(excl, release) -> F
eqt₂(excl, request) -> F
eqt₂(excl, resource) -> F
eqt₂(excl, tag) -> F
eqt₂(excl, true) -> F
eqt₂(excl, undefined) -> F
eqt₂(excl, pid₁(N2)) -> F
eqt₂(excl, eqt₂(false, int₁(N2))) -> F
eqt₂(false, cons₂(H2, T2)) -> F
eqt₂(false, tuple₂(H2, T2)) -> F
eqt₂(false, tuplenil₁(H2)) -> F
eqt₂(lock, nil) -> F
eqt₂(lock, a) -> F
eqt₂(lock, excl) -> F
eqt₂(lock, false) -> F
eqt₂(lock, lock) -> T
eqt₂(lock, locker) -> F
eqt₂(lock, mcrlrecord) -> F
eqt₂(lock, ok) -> F
eqt₂(lock, pending) -> F
eqt₂(lock, release) -> F
eqt₂(lock, request) -> F
eqt₂(lock, resource) -> F
eqt₂(lock, tag) -> F
eqt₂(lock, true) -> F
eqt₂(lock, undefined) -> F
eqt₂(lock, pid₁(N2)) -> F
eqt₂(lock, int₁(N2)) -> F
eqt₂(lock, cons₂(H2, T2)) -> F
eqt₂(lock, tuple₂(H2, T2)) -> F
eqt₂(lock, tuplenil₁(H2)) -> F
eqt₂(locker, nil) -> F
eqt₂(locker, a) -> F
eqt₂(locker, excl) -> F
eqt₂(locker, false) -> F
eqt₂(locker, lock) -> F
eqt₂(locker, locker) -> T
eqt₂(locker, mcrlrecord) -> F
eqt₂(locker, ok) -> F
eqt₂(locker, pending) -> F
eqt₂(locker, release) -> F
eqt₂(locker, request) -> F
eqt₂(locker, resource) -> F
eqt₂(locker, tag) -> F
eqt₂(locker, true) -> F
eqt₂(locker, undefined) -> F
eqt₂(locker, pid₁(N2)) -> F
eqt₂(locker, int₁(N2)) -> F
eqt₂(locker, cons₂(H2, T2)) -> F
eqt₂(locker, tuple₂(H2, T2)) -> F
eqt₂(locker, tuplenil₁(H2)) -> F
eqt₂(mcrlrecord, nil) -> F
eqt₂(mcrlrecord, a) -> F
eqt₂(mcrlrecord, excl) -> F
eqt₂(mcrlrecord, false) -> F
eqt₂(mcrlrecord, lock) -> F
eqt₂(mcrlrecord, locker) -> F
eqt₂(mcrlrecord, mcrlrecord) -> T
eqt₂(mcrlrecord, ok) -> F
eqt₂(mcrlrecord, pending) -> F
eqt₂(mcrlrecord, release) -> F
eqt₂(mcrlrecord, request) -> F
eqt₂(mcrlrecord, resource) -> F
eqt₂(ok, resource) -> F
eqt₂(ok, tag) -> F
eqt₂(ok, true) -> F
eqt₂(ok, undefined) -> F
eqt₂(ok, pid₁(N2)) -> F
eqt₂(ok, int₁(N2)) -> F
eqt₂(ok, cons₂(H2, T2)) -> F
eqt₂(ok, tuple₂(H2, T2)) -> F
eqt₂(ok, tuplenil₁(H2)) -> F
eqt₂(pending, nil) -> F
eqt₂(pending, a) -> F
eqt₂(pending, excl) -> F
eqt₂(pending, false) -> F
eqt₂(pending, lock) -> F
eqt₂(pending, locker) -> F
eqt₂(pending, mcrlrecord) -> F
eqt₂(pending, ok) -> F
eqt₂(pending, pending) -> T
eqt₂(pending, release) -> F
eqt₂(pending, request) -> F
eqt₂(pending, resource) -> F
eqt₂(pending, tag) -> F
eqt₂(pending, true) -> F
eqt₂(pending, undefined) -> F
eqt₂(pending, pid₁(N2)) -> F
eqt₂(pending, int₁(N2)) -> F
eqt₂(pending, cons₂(H2, T2)) -> F
eqt₂(pending, tuple₂(H2, T2)) -> F
eqt₂(pending, tuplenil₁(H2)) -> F
eqt₂(release, nil) -> F
eqt₂(release, a) -> F
eqt₂(release, excl) -> F
eqt₂(release, false) -> F
eqt₂(release, lock) -> F
eqt₂(release, locker) -> F
eqt₂(release, mcrlrecord) -> F
eqt₂(release, ok) -> F
eqt₂(request, mcrlrecord) -> F
eqt₂(request, ok) -> F
eqt₂(request, pending) -> F
eqt₂(request, release) -> F
eqt₂(request, request) -> T
eqt₂(request, resource) -> F
eqt₂(request, tag) -> F
eqt₂(request, true) -> F
eqt₂(request, undefined) -> F
eqt₂(request, pid₁(N2)) -> F
eqt₂(request, int₁(N2)) -> F
eqt₂(request, cons₂(H2, T2)) -> F
eqt₂(request, tuple₂(H2, T2)) -> F
eqt₂(request, tuplenil₁(H2)) -> F
eqt₂(resource, nil) -> F
eqt₂(resource, a) -> F
eqt₂(resource, excl) -> F
eqt₂(resource, false) -> F
eqt₂(resource, lock) -> F
eqt₂(resource, locker) -> F
eqt₂(resource, mcrlrecord) -> F
eqt₂(resource, ok) -> F
eqt₂(resource, pending) -> F
eqt₂(resource, release) -> F
eqt₂(resource, request) -> F
eqt₂(resource, resource) -> T
eqt₂(resource, tag) -> F
eqt₂(resource, true) -> F
eqt₂(resource, undefined) -> F
eqt₂(resource, pid₁(N2)) -> F
eqt₂(resource, int₁(N2)) -> F
eqt₂(resource, cons₂(H2, T2)) -> F
eqt₂(resource, tuple₂(H2, T2)) -> F
eqt₂(resource, tuplenil₁(H2)) -> F
eqt₂(tag, nil) -> F
eqt₂(tag, a) -> F
eqt₂(tag, excl) -> F
eqt₂(tag, false) -> F
eqt₂(tag, lock) -> F
eqt₂(tag, locker) -> F
eqt₂(tag, mcrlrecord) -> F
eqt₂(tag, ok) -> F
eqt₂(tag, pending) -> F
eqt₂(tag, release) -> F
eqt₂(tag, request) -> F
eqt₂(tag, resource) -> F
eqt₂(tag, tag) -> T
eqt₂(tag, true) -> F
eqt₂(tag, undefined) -> F
eqt₂(tag, pid₁(N2)) -> F
eqt₂(tag, int₁(N2)) -> F
eqt₂(tag, cons₂(H2, T2)) -> F
eqt₂(tag, tuple₂(H2, T2)) -> F
eqt₂(tag, tuplenil₁(H2)) -> F
eqt₂(true, nil) -> F
eqt₂(true, a) -> F
eqt₂(true, excl) -> F
eqt₂(true, false) -> F
eqt₂(true, lock) -> F
eqt₂(true, locker) -> F
eqt₂(true, mcrlrecord) -> F
eqt₂(true, ok) -> F
eqt₂(true, pending) -> F
eqt₂(true, release) -> F
eqt₂(true, request) -> F
eqt₂(true, resource) -> F
eqt₂(true, tag) -> F
eqt₂(true, true) -> T
eqt₂(true, undefined) -> F
eqt₂(true, pid₁(N2)) -> F
eqt₂(true, int₁(N2)) -> F
eqt₂(true, cons₂(H2, T2)) -> F
eqt₂(true, tuple₂(H2, T2)) -> F
eqt₂(true, tuplenil₁(H2)) -> F
eqt₂(undefined, nil) -> F
eqt₂(undefined, a) -> F
eqt₂(undefined, tuplenil₁(H2)) -> F
eqt₂(pid₁(N1), nil) -> F
eqt₂(pid₁(N1), a) -> F
eqt₂(pid₁(N1), excl) -> F
eqt₂(pid₁(N1), false) -> F
eqt₂(pid₁(N1), lock) -> F
eqt₂(pid₁(N1), locker) -> F
eqt₂(pid₁(N1), mcrlrecord) -> F
eqt₂(pid₁(N1), ok) -> F
eqt₂(pid₁(N1), pending) -> F
eqt₂(pid₁(N1), release) -> F
eqt₂(pid₁(N1), request) -> F
eqt₂(pid₁(N1), resource) -> F
eqt₂(pid₁(N1), tag) -> F
eqt₂(pid₁(N1), true) -> F
eqt₂(pid₁(N1), undefined) -> F
eqt₂(pid₁(N1), pid₁(N2)) -> eqt₂(N1, N2)
eqt₂(pid₁(N1), int₁(N2)) -> F
eqt₂(pid₁(N1), cons₂(H2, T2)) -> F
eqt₂(pid₁(N1), tuple₂(H2, T2)) -> F
eqt₂(pid₁(N1), tuplenil₁(H2)) -> F
eqt₂(int₁(N1), nil) -> F
eqt₂(int₁(N1), a) -> F
eqt₂(int₁(N1), excl) -> F
eqt₂(int₁(N1), false) -> F
eqt₂(int₁(N1), lock) -> F
eqt₂(int₁(N1), locker) -> F
eqt₂(int₁(N1), mcrlrecord) -> F
eqt₂(int₁(N1), ok) -> F
eqt₂(int₁(N1), pending) -> F
eqt₂(int₁(N1), release) -> F
eqt₂(int₁(N1), request) -> F
eqt₂(int₁(N1), resource) -> F
eqt₂(int₁(N1), tag) -> F
eqt₂(int₁(N1), true) -> F
eqt₂(int₁(N1), undefined) -> F
eqt₂(cons₂(H1, T1), resource) -> F
eqt₂(cons₂(H1, T1), tag) -> F
eqt₂(cons₂(H1, T1), true) -> F
eqt₂(cons₂(H1, T1), undefined) -> F
eqt₂(cons₂(H1, T1), pid₁(N2)) -> F
eqt₂(cons₂(H1, T1), int₁(N2)) -> F
eqt₂(cons₂(H1, T1), cons₂(H2, T2)) -> and₂(eqt₂(H1, H2), eqt₂(T1, T2))
eqt₂(cons₂(H1, T1), tuple₂(H2, T2)) -> F
eqt₂(cons₂(H1, T1), tuplenil₁(H2)) -> F
eqt₂(tuple₂(H1, T1), nil) -> F
eqt₂(tuple₂(H1, T1), a) -> F
eqt₂(tuple₂(H1, T1), excl) -> F
eqt₂(tuple₂(H1, T1), false) -> F
eqt₂(tuple₂(H1, T1), lock) -> F
eqt₂(tuple₂(H1, T1), locker) -> F
eqt₂(tuple₂(H1, T1), mcrlrecord) -> F
eqt₂(tuple₂(H1, T1), ok) -> F
eqt₂(tuple₂(H1, T1), pending) -> F
eqt₂(tuple₂(H1, T1), release) -> F
eqt₂(tuple₂(H1, T1), request) -> F
eqt₂(tuple₂(H1, T1), resource) -> F
eqt₂(tuple₂(H1, T1), tag) -> F
eqt₂(tuple₂(H1, T1), true) -> F
eqt₂(tuple₂(H1, T1), undefined) -> F
eqt₂(tuple₂(H1, T1), pid₁(N2)) -> F
eqt₂(tuple₂(H1, T1), int₁(N2)) -> F
eqt₂(tuple₂(H1, T1), cons₂(H2, T2)) -> F
eqt₂(tuple₂(H1, T1), tuple₂(H2, T2)) -> and₂(eqt₂(H1, H2), eqt₂(T1, T2))
eqt₂(tuple₂(H1, T1), tuplenil₁(H2)) -> F
eqt₂(tuplenil₁(H1), nil) -> F
eqt₂(tuplenil₁(H1), a) -> F
eqt₂(tuplenil₁(H1), excl) -> F
eqt₂(tuplenil₁(H1), false) -> F
eqt₂(tuplenil₁(H1), lock) -> F
eqt₂(tuplenil₁(H1), locker) -> F
eqt₂(tuplenil₁(H1), mcrlrecord) -> F
eqt₂(tuplenil₁(H1), ok) -> F
eqt₂(tuplenil₁(H1), pending) -> F
eqt₂(tuplenil₁(H1), release) -> F
eqt₂(tuplenil₁(H1), request) -> F
eqt₂(tuplenil₁(H1), resource) -> F
eqt₂(tuplenil₁(H1), tag) -> F
eqt₂(tuplenil₁(H1), true) -> F
eqt₂(tuplenil₁(H1), undefined) -> F
eqt₂(tuplenil₁(H1), pid₁(N2)) -> F
eqt₂(tuplenil₁(H1), int₁(N2)) -> F
eqt₂(tuplenil₁(H1), cons₂(H2, T2)) -> F
eqt₂(tuplenil₁(H1), tuple₂(H2, T2)) -> F
eqt₂(tuplenil₁(H1), tuplenil₁(H2)) -> eqt₂(H1, H2)
element₂(int₁(s₁(0)), tuplenil₁(T1)) -> T1
element₂(int₁(s₁(0)), tuple₂(T1, T2)) -> T1
element₂(int₁(s₁(s₁(N1))), tuple₂(T1, T2)) -> element₂(int₁(s₁(N1)), T2)
record_new₁(lock) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(undefined, tuple₂(nil, tuplenil₁(nil)))))
record_extract₃(tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2))))), lock, resource) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2)))))
record_update₄(tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2))))), lock, pending, NewF) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(NewF)))))
record_updates₃(Record, Name, nil) -> Record
record_updates₃(Record, Name, cons₂(tuple₂(Field, tuplenil₁(NewF)), Fields)) -> record_updates₃(record_update₄(Record, Name, Field, NewF), Name, Fields)
locker2_map_promote_pending₂(nil, Pending) -> nil
locker2_map_promote_pending₂(cons₂(Lock, Locks), Pending) -> cons₂(locker2_promote_pending₂(Lock, Pending), locker2_map_promote_pending₂(Locks, Pending))
locker2_map_claim_lock₃(nil, Resources, Client) -> nil
locker2_map_claim_lock₃(cons₂(Lock, Locks), Resources, Client) -> cons₂(locker2_claim_lock₃(Lock, Resources, Client), locker2_map_claim_lock₃(Locks, Resources, Client))
locker2_map_add_pending₃(nil, Resources, Client) -> nil
locker2_promote_pending₂(Lock, Client) -> case0₃(Client, Lock, record_extract₃(Lock, lock, pending))
case0₃(Client, Lock, cons₂(Client, Pendings)) -> record_updates₃(Lock, lock, cons₂(tuple₂(excl, tuplenil₁(Client)), cons₂(tuple₂(pending, tuplenil₁(Pendings)), nil)))
case0₃(Client, Lock, MCRLFree0) -> Lock
locker2_remove_pending₂(Lock, Client) -> record_updates₃(Lock, lock, cons₂(tuple₂(pending, tuplenil₁(subtract₂(record_extract₃(Lock, lock, pending), cons₂(Client, nil)))), nil))
locker2_add_pending₃(Lock, Resources, Client) -> case1₄(Client, Resources, Lock, member₂(record_extract₃(Lock, lock, resource), Resources))
case1₄(Client, Resources, Lock, true) -> record_updates₃(Lock, lock, cons₂(tuple₂(pending, tuplenil₁(append₂(record_extract₃(Lock, lock, pending), cons₂(Client, nil)))), nil))
case1₄(Client, Resources, Lock, false) -> Lock
locker2_release_lock₂(Lock, Client) -> case2₃(Client, Lock, gen_modtageq₂(Client, record_extract₃(Lock, lock, excl)))
case2₃(Client, Lock, true) -> record_updates₃(Lock, lock, cons₂(tuple₂(excllock, excl), nil))
case4₃(Client, Lock, MCRLFree1) -> false
locker2_obtainables₂(nil, Client) -> true
locker2_obtainables₂(cons₂(Lock, Locks), Client) -> case5₄(Client, Locks, Lock, member₂(Client, record_extract₃(Lock, lock, pending)))
case5₄(Client, Locks, Lock, true) -> andt₂(locker2_obtainable₂(Lock, Client), locker2_obtainables₂(Locks, Client))
case5₄(Client, Locks, Lock, false) -> locker2_obtainables₂(Locks, Client)
locker2_check_available₂(Resource, nil) -> false
locker2_check_available₂(Resource, cons₂(Lock, Locks)) -> case6₄(Locks, Lock, Resource, equal₂(Resource, record_extract₃(Lock, lock, resource)))
case6₄(Locks, Lock, Resource, true) -> andt₂(equal₂(record_extract₃(Lock, lock, excl), nil), equal₂(record_extract₃(Lock, lock, pending), nil))
case6₄(Locks, Lock, Resource, false) -> locker2_check_available₂(Resource, Locks)
locker2_check_availables₂(nil, Locks) -> true
locker2_check_availables₂(cons₂(Resource, Resources), Locks) -> andt₂(locker2_check_available₂(Resource, Locks), locker2_check_availables₂(Resources, Locks))
locker2_adduniq₂(nil, List) -> List
append₂(cons₂(Head, Tail), List) -> cons₂(Head, append₂(Tail, List))
subtract₂(List, nil) -> List
subtract₂(List, cons₂(Head, Tail)) -> subtract₂(delete₂(Head, List), Tail)
delete₂(E, nil) -> nil
delete₂(E, cons₂(Head, Tail)) -> case8₄(Tail, Head, E, equal₂(E, Head))
case8₄(Tail, Head, E, true) -> Tail
case8₄(Tail, Head, E, false) -> cons₂(Head, delete₂(E, Tail))
gen_tag₁(Pid) -> tuple₂(Pid, tuplenil₁(tag))
gen_modtageq₂(Client1, Client2) -> equal₂(Client1, Client2)
member₂(E, nil) -> false
member₂(E, cons₂(Head, Tail)) -> case9₄(Tail, Head, E, equal₂(E, Head))
case9₄(Tail, Head, E, true) -> true
case9₄(Tail, Head, E, false) -> member₂(E, Tail)
eqs₂(empty, empty) -> T
eqs₂(empty, stack₂(E2, S2)) -> F
eqs₂(stack₂(E1, S1), empty) -> F
eqs₂(stack₂(E1, S1), stack₂(E2, S2)) -> and₂(eqt₂(E1, E2), eqs₂(S1, S2))
pushs₂(E1, S1) -> stack₂(E1, S1)
pops₁(stack₂(E1, S1)) -> S1
tops₁(stack₂(E1, S1)) -> E1
istops₂(E1, empty) -> F
istops₂(E1, stack₂(E2, S1)) -> eqt₂(E1, E2)
eqc₂(nocalls, nocalls) -> T
eqc₂(nocalls, calls₃(E2, S2, CS2)) -> F
eqc₂(calls₃(E1, S1, CS1), nocalls) -> F
eqc₂(calls₃(E1, S1, CS1), calls₃(E2, S2, CS2)) -> and₂(eqt₂(E1, E2), and₂(eqs₂(S1, S2), eqc₂(CS1, CS2)))
push₃(E1, E2, nocalls) -> calls₃(E1, stack₂(E2, empty), nocalls)
push₃(E1, E2, calls₃(E3, S1, CS1)) -> push1₆(E1, E2, E3, S1, CS1, eqt₂(E1, E3))
push1₆(E1, E2, E3, S1, CS1, T) -> calls₃(E3, pushs₂(E2, S1), CS1)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

EQT₂(tuplenil₁(H1), tuplenil₁(H2)) -> EQT₂(H1, H2)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial Order [17,21] with Interpretation:

POL( tuplenil₁(x₁) ) = x₁ + 1

POL( EQT₂(x₁, x₂) ) = x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

or₂(T, T) -> T
or₂(F, T) -> T
or₂(T, F) -> T
or₂(F, F) -> F
and₂(T, B) -> B
and₂(B, T) -> B
and₂(F, B) -> F
and₂(B, F) -> F
imp₂(T, B) -> B
imp₂(F, B) -> T
not₁(T) -> F
not₁(F) -> T
if₃(T, B1, B2) -> B1
if₃(F, B1, B2) -> B2
eq₂(T, T) -> T
eq₂(F, F) -> T
eq₂(T, F) -> F
eq₂(F, T) -> F
eqt₂(nil, undefined) -> F
eqt₂(nil, pid₁(N2)) -> F
eqt₂(nil, int₁(N2)) -> F
eqt₂(nil, cons₂(H2, T2)) -> F
eqt₂(nil, tuple₂(H2, T2)) -> F
eqt₂(nil, tuplenil₁(H2)) -> F
eqt₂(a, nil) -> F
eqt₂(a, a) -> T
eqt₂(a, excl) -> F
eqt₂(a, false) -> F
eqt₂(a, lock) -> F
eqt₂(a, locker) -> F
eqt₂(a, mcrlrecord) -> F
eqt₂(a, ok) -> F
eqt₂(a, pending) -> F
eqt₂(a, release) -> F
eqt₂(a, request) -> F
eqt₂(a, resource) -> F
eqt₂(a, tag) -> F
eqt₂(a, true) -> F
eqt₂(a, undefined) -> F
eqt₂(a, pid₁(N2)) -> F
eqt₂(a, int₁(N2)) -> F
eqt₂(a, cons₂(H2, T2)) -> F
eqt₂(a, tuple₂(H2, T2)) -> F
eqt₂(a, tuplenil₁(H2)) -> F
eqt₂(excl, nil) -> F
eqt₂(excl, a) -> F
eqt₂(excl, excl) -> T
eqt₂(excl, false) -> F
eqt₂(excl, lock) -> F
eqt₂(excl, locker) -> F
eqt₂(excl, mcrlrecord) -> F
eqt₂(excl, ok) -> F
eqt₂(excl, pending) -> F
eqt₂(excl, release) -> F
eqt₂(excl, request) -> F
eqt₂(excl, resource) -> F
eqt₂(excl, tag) -> F
eqt₂(excl, true) -> F
eqt₂(excl, undefined) -> F
eqt₂(excl, pid₁(N2)) -> F
eqt₂(excl, eqt₂(false, int₁(N2))) -> F
eqt₂(false, cons₂(H2, T2)) -> F
eqt₂(false, tuple₂(H2, T2)) -> F
eqt₂(false, tuplenil₁(H2)) -> F
eqt₂(lock, nil) -> F
eqt₂(lock, a) -> F
eqt₂(lock, excl) -> F
eqt₂(lock, false) -> F
eqt₂(lock, lock) -> T
eqt₂(lock, locker) -> F
eqt₂(lock, mcrlrecord) -> F
eqt₂(lock, ok) -> F
eqt₂(lock, pending) -> F
eqt₂(lock, release) -> F
eqt₂(lock, request) -> F
eqt₂(lock, resource) -> F
eqt₂(lock, tag) -> F
eqt₂(lock, true) -> F
eqt₂(lock, undefined) -> F
eqt₂(lock, pid₁(N2)) -> F
eqt₂(lock, int₁(N2)) -> F
eqt₂(lock, cons₂(H2, T2)) -> F
eqt₂(lock, tuple₂(H2, T2)) -> F
eqt₂(lock, tuplenil₁(H2)) -> F
eqt₂(locker, nil) -> F
eqt₂(locker, a) -> F
eqt₂(locker, excl) -> F
eqt₂(locker, false) -> F
eqt₂(locker, lock) -> F
eqt₂(locker, locker) -> T
eqt₂(locker, mcrlrecord) -> F
eqt₂(locker, ok) -> F
eqt₂(locker, pending) -> F
eqt₂(locker, release) -> F
eqt₂(locker, request) -> F
eqt₂(locker, resource) -> F
eqt₂(locker, tag) -> F
eqt₂(locker, true) -> F
eqt₂(locker, undefined) -> F
eqt₂(locker, pid₁(N2)) -> F
eqt₂(locker, int₁(N2)) -> F
eqt₂(locker, cons₂(H2, T2)) -> F
eqt₂(locker, tuple₂(H2, T2)) -> F
eqt₂(locker, tuplenil₁(H2)) -> F
eqt₂(mcrlrecord, nil) -> F
eqt₂(mcrlrecord, a) -> F
eqt₂(mcrlrecord, excl) -> F
eqt₂(mcrlrecord, false) -> F
eqt₂(mcrlrecord, lock) -> F
eqt₂(mcrlrecord, locker) -> F
eqt₂(mcrlrecord, mcrlrecord) -> T
eqt₂(mcrlrecord, ok) -> F
eqt₂(mcrlrecord, pending) -> F
eqt₂(mcrlrecord, release) -> F
eqt₂(mcrlrecord, request) -> F
eqt₂(mcrlrecord, resource) -> F
eqt₂(ok, resource) -> F
eqt₂(ok, tag) -> F
eqt₂(ok, true) -> F
eqt₂(ok, undefined) -> F
eqt₂(ok, pid₁(N2)) -> F
eqt₂(ok, int₁(N2)) -> F
eqt₂(ok, cons₂(H2, T2)) -> F
eqt₂(ok, tuple₂(H2, T2)) -> F
eqt₂(ok, tuplenil₁(H2)) -> F
eqt₂(pending, nil) -> F
eqt₂(pending, a) -> F
eqt₂(pending, excl) -> F
eqt₂(pending, false) -> F
eqt₂(pending, lock) -> F
eqt₂(pending, locker) -> F
eqt₂(pending, mcrlrecord) -> F
eqt₂(pending, ok) -> F
eqt₂(pending, pending) -> T
eqt₂(pending, release) -> F
eqt₂(pending, request) -> F
eqt₂(pending, resource) -> F
eqt₂(pending, tag) -> F
eqt₂(pending, true) -> F
eqt₂(pending, undefined) -> F
eqt₂(pending, pid₁(N2)) -> F
eqt₂(pending, int₁(N2)) -> F
eqt₂(pending, cons₂(H2, T2)) -> F
eqt₂(pending, tuple₂(H2, T2)) -> F
eqt₂(pending, tuplenil₁(H2)) -> F
eqt₂(release, nil) -> F
eqt₂(release, a) -> F
eqt₂(release, excl) -> F
eqt₂(release, false) -> F
eqt₂(release, lock) -> F
eqt₂(release, locker) -> F
eqt₂(release, mcrlrecord) -> F
eqt₂(release, ok) -> F
eqt₂(request, mcrlrecord) -> F
eqt₂(request, ok) -> F
eqt₂(request, pending) -> F
eqt₂(request, release) -> F
eqt₂(request, request) -> T
eqt₂(request, resource) -> F
eqt₂(request, tag) -> F
eqt₂(request, true) -> F
eqt₂(request, undefined) -> F
eqt₂(request, pid₁(N2)) -> F
eqt₂(request, int₁(N2)) -> F
eqt₂(request, cons₂(H2, T2)) -> F
eqt₂(request, tuple₂(H2, T2)) -> F
eqt₂(request, tuplenil₁(H2)) -> F
eqt₂(resource, nil) -> F
eqt₂(resource, a) -> F
eqt₂(resource, excl) -> F
eqt₂(resource, false) -> F
eqt₂(resource, lock) -> F
eqt₂(resource, locker) -> F
eqt₂(resource, mcrlrecord) -> F
eqt₂(resource, ok) -> F
eqt₂(resource, pending) -> F
eqt₂(resource, release) -> F
eqt₂(resource, request) -> F
eqt₂(resource, resource) -> T
eqt₂(resource, tag) -> F
eqt₂(resource, true) -> F
eqt₂(resource, undefined) -> F
eqt₂(resource, pid₁(N2)) -> F
eqt₂(resource, int₁(N2)) -> F
eqt₂(resource, cons₂(H2, T2)) -> F
eqt₂(resource, tuple₂(H2, T2)) -> F
eqt₂(resource, tuplenil₁(H2)) -> F
eqt₂(tag, nil) -> F
eqt₂(tag, a) -> F
eqt₂(tag, excl) -> F
eqt₂(tag, false) -> F
eqt₂(tag, lock) -> F
eqt₂(tag, locker) -> F
eqt₂(tag, mcrlrecord) -> F
eqt₂(tag, ok) -> F
eqt₂(tag, pending) -> F
eqt₂(tag, release) -> F
eqt₂(tag, request) -> F
eqt₂(tag, resource) -> F
eqt₂(tag, tag) -> T
eqt₂(tag, true) -> F
eqt₂(tag, undefined) -> F
eqt₂(tag, pid₁(N2)) -> F
eqt₂(tag, int₁(N2)) -> F
eqt₂(tag, cons₂(H2, T2)) -> F
eqt₂(tag, tuple₂(H2, T2)) -> F
eqt₂(tag, tuplenil₁(H2)) -> F
eqt₂(true, nil) -> F
eqt₂(true, a) -> F
eqt₂(true, excl) -> F
eqt₂(true, false) -> F
eqt₂(true, lock) -> F
eqt₂(true, locker) -> F
eqt₂(true, mcrlrecord) -> F
eqt₂(true, ok) -> F
eqt₂(true, pending) -> F
eqt₂(true, release) -> F
eqt₂(true, request) -> F
eqt₂(true, resource) -> F
eqt₂(true, tag) -> F
eqt₂(true, true) -> T
eqt₂(true, undefined) -> F
eqt₂(true, pid₁(N2)) -> F
eqt₂(true, int₁(N2)) -> F
eqt₂(true, cons₂(H2, T2)) -> F
eqt₂(true, tuple₂(H2, T2)) -> F
eqt₂(true, tuplenil₁(H2)) -> F
eqt₂(undefined, nil) -> F
eqt₂(undefined, a) -> F
eqt₂(undefined, tuplenil₁(H2)) -> F
eqt₂(pid₁(N1), nil) -> F
eqt₂(pid₁(N1), a) -> F
eqt₂(pid₁(N1), excl) -> F
eqt₂(pid₁(N1), false) -> F
eqt₂(pid₁(N1), lock) -> F
eqt₂(pid₁(N1), locker) -> F
eqt₂(pid₁(N1), mcrlrecord) -> F
eqt₂(pid₁(N1), ok) -> F
eqt₂(pid₁(N1), pending) -> F
eqt₂(pid₁(N1), release) -> F
eqt₂(pid₁(N1), request) -> F
eqt₂(pid₁(N1), resource) -> F
eqt₂(pid₁(N1), tag) -> F
eqt₂(pid₁(N1), true) -> F
eqt₂(pid₁(N1), undefined) -> F
eqt₂(pid₁(N1), pid₁(N2)) -> eqt₂(N1, N2)
eqt₂(pid₁(N1), int₁(N2)) -> F
eqt₂(pid₁(N1), cons₂(H2, T2)) -> F
eqt₂(pid₁(N1), tuple₂(H2, T2)) -> F
eqt₂(pid₁(N1), tuplenil₁(H2)) -> F
eqt₂(int₁(N1), nil) -> F
eqt₂(int₁(N1), a) -> F
eqt₂(int₁(N1), excl) -> F
eqt₂(int₁(N1), false) -> F
eqt₂(int₁(N1), lock) -> F
eqt₂(int₁(N1), locker) -> F
eqt₂(int₁(N1), mcrlrecord) -> F
eqt₂(int₁(N1), ok) -> F
eqt₂(int₁(N1), pending) -> F
eqt₂(int₁(N1), release) -> F
eqt₂(int₁(N1), request) -> F
eqt₂(int₁(N1), resource) -> F
eqt₂(int₁(N1), tag) -> F
eqt₂(int₁(N1), true) -> F
eqt₂(int₁(N1), undefined) -> F
eqt₂(cons₂(H1, T1), resource) -> F
eqt₂(cons₂(H1, T1), tag) -> F
eqt₂(cons₂(H1, T1), true) -> F
eqt₂(cons₂(H1, T1), undefined) -> F
eqt₂(cons₂(H1, T1), pid₁(N2)) -> F
eqt₂(cons₂(H1, T1), int₁(N2)) -> F
eqt₂(cons₂(H1, T1), cons₂(H2, T2)) -> and₂(eqt₂(H1, H2), eqt₂(T1, T2))
eqt₂(cons₂(H1, T1), tuple₂(H2, T2)) -> F
eqt₂(cons₂(H1, T1), tuplenil₁(H2)) -> F
eqt₂(tuple₂(H1, T1), nil) -> F
eqt₂(tuple₂(H1, T1), a) -> F
eqt₂(tuple₂(H1, T1), excl) -> F
eqt₂(tuple₂(H1, T1), false) -> F
eqt₂(tuple₂(H1, T1), lock) -> F
eqt₂(tuple₂(H1, T1), locker) -> F
eqt₂(tuple₂(H1, T1), mcrlrecord) -> F
eqt₂(tuple₂(H1, T1), ok) -> F
eqt₂(tuple₂(H1, T1), pending) -> F
eqt₂(tuple₂(H1, T1), release) -> F
eqt₂(tuple₂(H1, T1), request) -> F
eqt₂(tuple₂(H1, T1), resource) -> F
eqt₂(tuple₂(H1, T1), tag) -> F
eqt₂(tuple₂(H1, T1), true) -> F
eqt₂(tuple₂(H1, T1), undefined) -> F
eqt₂(tuple₂(H1, T1), pid₁(N2)) -> F
eqt₂(tuple₂(H1, T1), int₁(N2)) -> F
eqt₂(tuple₂(H1, T1), cons₂(H2, T2)) -> F
eqt₂(tuple₂(H1, T1), tuple₂(H2, T2)) -> and₂(eqt₂(H1, H2), eqt₂(T1, T2))
eqt₂(tuple₂(H1, T1), tuplenil₁(H2)) -> F
eqt₂(tuplenil₁(H1), nil) -> F
eqt₂(tuplenil₁(H1), a) -> F
eqt₂(tuplenil₁(H1), excl) -> F
eqt₂(tuplenil₁(H1), false) -> F
eqt₂(tuplenil₁(H1), lock) -> F
eqt₂(tuplenil₁(H1), locker) -> F
eqt₂(tuplenil₁(H1), mcrlrecord) -> F
eqt₂(tuplenil₁(H1), ok) -> F
eqt₂(tuplenil₁(H1), pending) -> F
eqt₂(tuplenil₁(H1), release) -> F
eqt₂(tuplenil₁(H1), request) -> F
eqt₂(tuplenil₁(H1), resource) -> F
eqt₂(tuplenil₁(H1), tag) -> F
eqt₂(tuplenil₁(H1), true) -> F
eqt₂(tuplenil₁(H1), undefined) -> F
eqt₂(tuplenil₁(H1), pid₁(N2)) -> F
eqt₂(tuplenil₁(H1), int₁(N2)) -> F
eqt₂(tuplenil₁(H1), cons₂(H2, T2)) -> F
eqt₂(tuplenil₁(H1), tuple₂(H2, T2)) -> F
eqt₂(tuplenil₁(H1), tuplenil₁(H2)) -> eqt₂(H1, H2)
element₂(int₁(s₁(0)), tuplenil₁(T1)) -> T1
element₂(int₁(s₁(0)), tuple₂(T1, T2)) -> T1
element₂(int₁(s₁(s₁(N1))), tuple₂(T1, T2)) -> element₂(int₁(s₁(N1)), T2)
record_new₁(lock) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(undefined, tuple₂(nil, tuplenil₁(nil)))))
record_extract₃(tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2))))), lock, resource) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2)))))
record_update₄(tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2))))), lock, pending, NewF) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(NewF)))))
record_updates₃(Record, Name, nil) -> Record
record_updates₃(Record, Name, cons₂(tuple₂(Field, tuplenil₁(NewF)), Fields)) -> record_updates₃(record_update₄(Record, Name, Field, NewF), Name, Fields)
locker2_map_promote_pending₂(nil, Pending) -> nil
locker2_map_promote_pending₂(cons₂(Lock, Locks), Pending) -> cons₂(locker2_promote_pending₂(Lock, Pending), locker2_map_promote_pending₂(Locks, Pending))
locker2_map_claim_lock₃(nil, Resources, Client) -> nil
locker2_map_claim_lock₃(cons₂(Lock, Locks), Resources, Client) -> cons₂(locker2_claim_lock₃(Lock, Resources, Client), locker2_map_claim_lock₃(Locks, Resources, Client))
locker2_map_add_pending₃(nil, Resources, Client) -> nil
locker2_promote_pending₂(Lock, Client) -> case0₃(Client, Lock, record_extract₃(Lock, lock, pending))
case0₃(Client, Lock, cons₂(Client, Pendings)) -> record_updates₃(Lock, lock, cons₂(tuple₂(excl, tuplenil₁(Client)), cons₂(tuple₂(pending, tuplenil₁(Pendings)), nil)))
case0₃(Client, Lock, MCRLFree0) -> Lock
locker2_remove_pending₂(Lock, Client) -> record_updates₃(Lock, lock, cons₂(tuple₂(pending, tuplenil₁(subtract₂(record_extract₃(Lock, lock, pending), cons₂(Client, nil)))), nil))
locker2_add_pending₃(Lock, Resources, Client) -> case1₄(Client, Resources, Lock, member₂(record_extract₃(Lock, lock, resource), Resources))
case1₄(Client, Resources, Lock, true) -> record_updates₃(Lock, lock, cons₂(tuple₂(pending, tuplenil₁(append₂(record_extract₃(Lock, lock, pending), cons₂(Client, nil)))), nil))
case1₄(Client, Resources, Lock, false) -> Lock
locker2_release_lock₂(Lock, Client) -> case2₃(Client, Lock, gen_modtageq₂(Client, record_extract₃(Lock, lock, excl)))
case2₃(Client, Lock, true) -> record_updates₃(Lock, lock, cons₂(tuple₂(excllock, excl), nil))
case4₃(Client, Lock, MCRLFree1) -> false
locker2_obtainables₂(nil, Client) -> true
locker2_obtainables₂(cons₂(Lock, Locks), Client) -> case5₄(Client, Locks, Lock, member₂(Client, record_extract₃(Lock, lock, pending)))
case5₄(Client, Locks, Lock, true) -> andt₂(locker2_obtainable₂(Lock, Client), locker2_obtainables₂(Locks, Client))
case5₄(Client, Locks, Lock, false) -> locker2_obtainables₂(Locks, Client)
locker2_check_available₂(Resource, nil) -> false
locker2_check_available₂(Resource, cons₂(Lock, Locks)) -> case6₄(Locks, Lock, Resource, equal₂(Resource, record_extract₃(Lock, lock, resource)))
case6₄(Locks, Lock, Resource, true) -> andt₂(equal₂(record_extract₃(Lock, lock, excl), nil), equal₂(record_extract₃(Lock, lock, pending), nil))
case6₄(Locks, Lock, Resource, false) -> locker2_check_available₂(Resource, Locks)
locker2_check_availables₂(nil, Locks) -> true
locker2_check_availables₂(cons₂(Resource, Resources), Locks) -> andt₂(locker2_check_available₂(Resource, Locks), locker2_check_availables₂(Resources, Locks))
locker2_adduniq₂(nil, List) -> List
append₂(cons₂(Head, Tail), List) -> cons₂(Head, append₂(Tail, List))
subtract₂(List, nil) -> List
subtract₂(List, cons₂(Head, Tail)) -> subtract₂(delete₂(Head, List), Tail)
delete₂(E, nil) -> nil
delete₂(E, cons₂(Head, Tail)) -> case8₄(Tail, Head, E, equal₂(E, Head))
case8₄(Tail, Head, E, true) -> Tail
case8₄(Tail, Head, E, false) -> cons₂(Head, delete₂(E, Tail))
gen_tag₁(Pid) -> tuple₂(Pid, tuplenil₁(tag))
gen_modtageq₂(Client1, Client2) -> equal₂(Client1, Client2)
member₂(E, nil) -> false
member₂(E, cons₂(Head, Tail)) -> case9₄(Tail, Head, E, equal₂(E, Head))
case9₄(Tail, Head, E, true) -> true
case9₄(Tail, Head, E, false) -> member₂(E, Tail)
eqs₂(empty, empty) -> T
eqs₂(empty, stack₂(E2, S2)) -> F
eqs₂(stack₂(E1, S1), empty) -> F
eqs₂(stack₂(E1, S1), stack₂(E2, S2)) -> and₂(eqt₂(E1, E2), eqs₂(S1, S2))
pushs₂(E1, S1) -> stack₂(E1, S1)
pops₁(stack₂(E1, S1)) -> S1
tops₁(stack₂(E1, S1)) -> E1
istops₂(E1, empty) -> F
istops₂(E1, stack₂(E2, S1)) -> eqt₂(E1, E2)
eqc₂(nocalls, nocalls) -> T
eqc₂(nocalls, calls₃(E2, S2, CS2)) -> F
eqc₂(calls₃(E1, S1, CS1), nocalls) -> F
eqc₂(calls₃(E1, S1, CS1), calls₃(E2, S2, CS2)) -> and₂(eqt₂(E1, E2), and₂(eqs₂(S1, S2), eqc₂(CS1, CS2)))
push₃(E1, E2, nocalls) -> calls₃(E1, stack₂(E2, empty), nocalls)
push₃(E1, E2, calls₃(E3, S1, CS1)) -> push1₆(E1, E2, E3, S1, CS1, eqt₂(E1, E3))
push1₆(E1, E2, E3, S1, CS1, T) -> calls₃(E3, pushs₂(E2, S1), CS1)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

EQS₂(stack₂(E1, S1), stack₂(E2, S2)) -> EQS₂(S1, S2)

The TRS R consists of the following rules:

or₂(T, T) -> T
or₂(F, T) -> T
or₂(T, F) -> T
or₂(F, F) -> F
and₂(T, B) -> B
and₂(B, T) -> B
and₂(F, B) -> F
and₂(B, F) -> F
imp₂(T, B) -> B
imp₂(F, B) -> T
not₁(T) -> F
not₁(F) -> T
if₃(T, B1, B2) -> B1
if₃(F, B1, B2) -> B2
eq₂(T, T) -> T
eq₂(F, F) -> T
eq₂(T, F) -> F
eq₂(F, T) -> F
eqt₂(nil, undefined) -> F
eqt₂(nil, pid₁(N2)) -> F
eqt₂(nil, int₁(N2)) -> F
eqt₂(nil, cons₂(H2, T2)) -> F
eqt₂(nil, tuple₂(H2, T2)) -> F
eqt₂(nil, tuplenil₁(H2)) -> F
eqt₂(a, nil) -> F
eqt₂(a, a) -> T
eqt₂(a, excl) -> F
eqt₂(a, false) -> F
eqt₂(a, lock) -> F
eqt₂(a, locker) -> F
eqt₂(a, mcrlrecord) -> F
eqt₂(a, ok) -> F
eqt₂(a, pending) -> F
eqt₂(a, release) -> F
eqt₂(a, request) -> F
eqt₂(a, resource) -> F
eqt₂(a, tag) -> F
eqt₂(a, true) -> F
eqt₂(a, undefined) -> F
eqt₂(a, pid₁(N2)) -> F
eqt₂(a, int₁(N2)) -> F
eqt₂(a, cons₂(H2, T2)) -> F
eqt₂(a, tuple₂(H2, T2)) -> F
eqt₂(a, tuplenil₁(H2)) -> F
eqt₂(excl, nil) -> F
eqt₂(excl, a) -> F
eqt₂(excl, excl) -> T
eqt₂(excl, false) -> F
eqt₂(excl, lock) -> F
eqt₂(excl, locker) -> F
eqt₂(excl, mcrlrecord) -> F
eqt₂(excl, ok) -> F
eqt₂(excl, pending) -> F
eqt₂(excl, release) -> F
eqt₂(excl, request) -> F
eqt₂(excl, resource) -> F
eqt₂(excl, tag) -> F
eqt₂(excl, true) -> F
eqt₂(excl, undefined) -> F
eqt₂(excl, pid₁(N2)) -> F
eqt₂(excl, eqt₂(false, int₁(N2))) -> F
eqt₂(false, cons₂(H2, T2)) -> F
eqt₂(false, tuple₂(H2, T2)) -> F
eqt₂(false, tuplenil₁(H2)) -> F
eqt₂(lock, nil) -> F
eqt₂(lock, a) -> F
eqt₂(lock, excl) -> F
eqt₂(lock, false) -> F
eqt₂(lock, lock) -> T
eqt₂(lock, locker) -> F
eqt₂(lock, mcrlrecord) -> F
eqt₂(lock, ok) -> F
eqt₂(lock, pending) -> F
eqt₂(lock, release) -> F
eqt₂(lock, request) -> F
eqt₂(lock, resource) -> F
eqt₂(lock, tag) -> F
eqt₂(lock, true) -> F
eqt₂(lock, undefined) -> F
eqt₂(lock, pid₁(N2)) -> F
eqt₂(lock, int₁(N2)) -> F
eqt₂(lock, cons₂(H2, T2)) -> F
eqt₂(lock, tuple₂(H2, T2)) -> F
eqt₂(lock, tuplenil₁(H2)) -> F
eqt₂(locker, nil) -> F
eqt₂(locker, a) -> F
eqt₂(locker, excl) -> F
eqt₂(locker, false) -> F
eqt₂(locker, lock) -> F
eqt₂(locker, locker) -> T
eqt₂(locker, mcrlrecord) -> F
eqt₂(locker, ok) -> F
eqt₂(locker, pending) -> F
eqt₂(locker, release) -> F
eqt₂(locker, request) -> F
eqt₂(locker, resource) -> F
eqt₂(locker, tag) -> F
eqt₂(locker, true) -> F
eqt₂(locker, undefined) -> F
eqt₂(locker, pid₁(N2)) -> F
eqt₂(locker, int₁(N2)) -> F
eqt₂(locker, cons₂(H2, T2)) -> F
eqt₂(locker, tuple₂(H2, T2)) -> F
eqt₂(locker, tuplenil₁(H2)) -> F
eqt₂(mcrlrecord, nil) -> F
eqt₂(mcrlrecord, a) -> F
eqt₂(mcrlrecord, excl) -> F
eqt₂(mcrlrecord, false) -> F
eqt₂(mcrlrecord, lock) -> F
eqt₂(mcrlrecord, locker) -> F
eqt₂(mcrlrecord, mcrlrecord) -> T
eqt₂(mcrlrecord, ok) -> F
eqt₂(mcrlrecord, pending) -> F
eqt₂(mcrlrecord, release) -> F
eqt₂(mcrlrecord, request) -> F
eqt₂(mcrlrecord, resource) -> F
eqt₂(ok, resource) -> F
eqt₂(ok, tag) -> F
eqt₂(ok, true) -> F
eqt₂(ok, undefined) -> F
eqt₂(ok, pid₁(N2)) -> F
eqt₂(ok, int₁(N2)) -> F
eqt₂(ok, cons₂(H2, T2)) -> F
eqt₂(ok, tuple₂(H2, T2)) -> F
eqt₂(ok, tuplenil₁(H2)) -> F
eqt₂(pending, nil) -> F
eqt₂(pending, a) -> F
eqt₂(pending, excl) -> F
eqt₂(pending, false) -> F
eqt₂(pending, lock) -> F
eqt₂(pending, locker) -> F
eqt₂(pending, mcrlrecord) -> F
eqt₂(pending, ok) -> F
eqt₂(pending, pending) -> T
eqt₂(pending, release) -> F
eqt₂(pending, request) -> F
eqt₂(pending, resource) -> F
eqt₂(pending, tag) -> F
eqt₂(pending, true) -> F
eqt₂(pending, undefined) -> F
eqt₂(pending, pid₁(N2)) -> F
eqt₂(pending, int₁(N2)) -> F
eqt₂(pending, cons₂(H2, T2)) -> F
eqt₂(pending, tuple₂(H2, T2)) -> F
eqt₂(pending, tuplenil₁(H2)) -> F
eqt₂(release, nil) -> F
eqt₂(release, a) -> F
eqt₂(release, excl) -> F
eqt₂(release, false) -> F
eqt₂(release, lock) -> F
eqt₂(release, locker) -> F
eqt₂(release, mcrlrecord) -> F
eqt₂(release, ok) -> F
eqt₂(request, mcrlrecord) -> F
eqt₂(request, ok) -> F
eqt₂(request, pending) -> F
eqt₂(request, release) -> F
eqt₂(request, request) -> T
eqt₂(request, resource) -> F
eqt₂(request, tag) -> F
eqt₂(request, true) -> F
eqt₂(request, undefined) -> F
eqt₂(request, pid₁(N2)) -> F
eqt₂(request, int₁(N2)) -> F
eqt₂(request, cons₂(H2, T2)) -> F
eqt₂(request, tuple₂(H2, T2)) -> F
eqt₂(request, tuplenil₁(H2)) -> F
eqt₂(resource, nil) -> F
eqt₂(resource, a) -> F
eqt₂(resource, excl) -> F
eqt₂(resource, false) -> F
eqt₂(resource, lock) -> F
eqt₂(resource, locker) -> F
eqt₂(resource, mcrlrecord) -> F
eqt₂(resource, ok) -> F
eqt₂(resource, pending) -> F
eqt₂(resource, release) -> F
eqt₂(resource, request) -> F
eqt₂(resource, resource) -> T
eqt₂(resource, tag) -> F
eqt₂(resource, true) -> F
eqt₂(resource, undefined) -> F
eqt₂(resource, pid₁(N2)) -> F
eqt₂(resource, int₁(N2)) -> F
eqt₂(resource, cons₂(H2, T2)) -> F
eqt₂(resource, tuple₂(H2, T2)) -> F
eqt₂(resource, tuplenil₁(H2)) -> F
eqt₂(tag, nil) -> F
eqt₂(tag, a) -> F
eqt₂(tag, excl) -> F
eqt₂(tag, false) -> F
eqt₂(tag, lock) -> F
eqt₂(tag, locker) -> F
eqt₂(tag, mcrlrecord) -> F
eqt₂(tag, ok) -> F
eqt₂(tag, pending) -> F
eqt₂(tag, release) -> F
eqt₂(tag, request) -> F
eqt₂(tag, resource) -> F
eqt₂(tag, tag) -> T
eqt₂(tag, true) -> F
eqt₂(tag, undefined) -> F
eqt₂(tag, pid₁(N2)) -> F
eqt₂(tag, int₁(N2)) -> F
eqt₂(tag, cons₂(H2, T2)) -> F
eqt₂(tag, tuple₂(H2, T2)) -> F
eqt₂(tag, tuplenil₁(H2)) -> F
eqt₂(true, nil) -> F
eqt₂(true, a) -> F
eqt₂(true, excl) -> F
eqt₂(true, false) -> F
eqt₂(true, lock) -> F
eqt₂(true, locker) -> F
eqt₂(true, mcrlrecord) -> F
eqt₂(true, ok) -> F
eqt₂(true, pending) -> F
eqt₂(true, release) -> F
eqt₂(true, request) -> F
eqt₂(true, resource) -> F
eqt₂(true, tag) -> F
eqt₂(true, true) -> T
eqt₂(true, undefined) -> F
eqt₂(true, pid₁(N2)) -> F
eqt₂(true, int₁(N2)) -> F
eqt₂(true, cons₂(H2, T2)) -> F
eqt₂(true, tuple₂(H2, T2)) -> F
eqt₂(true, tuplenil₁(H2)) -> F
eqt₂(undefined, nil) -> F
eqt₂(undefined, a) -> F
eqt₂(undefined, tuplenil₁(H2)) -> F
eqt₂(pid₁(N1), nil) -> F
eqt₂(pid₁(N1), a) -> F
eqt₂(pid₁(N1), excl) -> F
eqt₂(pid₁(N1), false) -> F
eqt₂(pid₁(N1), lock) -> F
eqt₂(pid₁(N1), locker) -> F
eqt₂(pid₁(N1), mcrlrecord) -> F
eqt₂(pid₁(N1), ok) -> F
eqt₂(pid₁(N1), pending) -> F
eqt₂(pid₁(N1), release) -> F
eqt₂(pid₁(N1), request) -> F
eqt₂(pid₁(N1), resource) -> F
eqt₂(pid₁(N1), tag) -> F
eqt₂(pid₁(N1), true) -> F
eqt₂(pid₁(N1), undefined) -> F
eqt₂(pid₁(N1), pid₁(N2)) -> eqt₂(N1, N2)
eqt₂(pid₁(N1), int₁(N2)) -> F
eqt₂(pid₁(N1), cons₂(H2, T2)) -> F
eqt₂(pid₁(N1), tuple₂(H2, T2)) -> F
eqt₂(pid₁(N1), tuplenil₁(H2)) -> F
eqt₂(int₁(N1), nil) -> F
eqt₂(int₁(N1), a) -> F
eqt₂(int₁(N1), excl) -> F
eqt₂(int₁(N1), false) -> F
eqt₂(int₁(N1), lock) -> F
eqt₂(int₁(N1), locker) -> F
eqt₂(int₁(N1), mcrlrecord) -> F
eqt₂(int₁(N1), ok) -> F
eqt₂(int₁(N1), pending) -> F
eqt₂(int₁(N1), release) -> F
eqt₂(int₁(N1), request) -> F
eqt₂(int₁(N1), resource) -> F
eqt₂(int₁(N1), tag) -> F
eqt₂(int₁(N1), true) -> F
eqt₂(int₁(N1), undefined) -> F
eqt₂(cons₂(H1, T1), resource) -> F
eqt₂(cons₂(H1, T1), tag) -> F
eqt₂(cons₂(H1, T1), true) -> F
eqt₂(cons₂(H1, T1), undefined) -> F
eqt₂(cons₂(H1, T1), pid₁(N2)) -> F
eqt₂(cons₂(H1, T1), int₁(N2)) -> F
eqt₂(cons₂(H1, T1), cons₂(H2, T2)) -> and₂(eqt₂(H1, H2), eqt₂(T1, T2))
eqt₂(cons₂(H1, T1), tuple₂(H2, T2)) -> F
eqt₂(cons₂(H1, T1), tuplenil₁(H2)) -> F
eqt₂(tuple₂(H1, T1), nil) -> F
eqt₂(tuple₂(H1, T1), a) -> F
eqt₂(tuple₂(H1, T1), excl) -> F
eqt₂(tuple₂(H1, T1), false) -> F
eqt₂(tuple₂(H1, T1), lock) -> F
eqt₂(tuple₂(H1, T1), locker) -> F
eqt₂(tuple₂(H1, T1), mcrlrecord) -> F
eqt₂(tuple₂(H1, T1), ok) -> F
eqt₂(tuple₂(H1, T1), pending) -> F
eqt₂(tuple₂(H1, T1), release) -> F
eqt₂(tuple₂(H1, T1), request) -> F
eqt₂(tuple₂(H1, T1), resource) -> F
eqt₂(tuple₂(H1, T1), tag) -> F
eqt₂(tuple₂(H1, T1), true) -> F
eqt₂(tuple₂(H1, T1), undefined) -> F
eqt₂(tuple₂(H1, T1), pid₁(N2)) -> F
eqt₂(tuple₂(H1, T1), int₁(N2)) -> F
eqt₂(tuple₂(H1, T1), cons₂(H2, T2)) -> F
eqt₂(tuple₂(H1, T1), tuple₂(H2, T2)) -> and₂(eqt₂(H1, H2), eqt₂(T1, T2))
eqt₂(tuple₂(H1, T1), tuplenil₁(H2)) -> F
eqt₂(tuplenil₁(H1), nil) -> F
eqt₂(tuplenil₁(H1), a) -> F
eqt₂(tuplenil₁(H1), excl) -> F
eqt₂(tuplenil₁(H1), false) -> F
eqt₂(tuplenil₁(H1), lock) -> F
eqt₂(tuplenil₁(H1), locker) -> F
eqt₂(tuplenil₁(H1), mcrlrecord) -> F
eqt₂(tuplenil₁(H1), ok) -> F
eqt₂(tuplenil₁(H1), pending) -> F
eqt₂(tuplenil₁(H1), release) -> F
eqt₂(tuplenil₁(H1), request) -> F
eqt₂(tuplenil₁(H1), resource) -> F
eqt₂(tuplenil₁(H1), tag) -> F
eqt₂(tuplenil₁(H1), true) -> F
eqt₂(tuplenil₁(H1), undefined) -> F
eqt₂(tuplenil₁(H1), pid₁(N2)) -> F
eqt₂(tuplenil₁(H1), int₁(N2)) -> F
eqt₂(tuplenil₁(H1), cons₂(H2, T2)) -> F
eqt₂(tuplenil₁(H1), tuple₂(H2, T2)) -> F
eqt₂(tuplenil₁(H1), tuplenil₁(H2)) -> eqt₂(H1, H2)
element₂(int₁(s₁(0)), tuplenil₁(T1)) -> T1
element₂(int₁(s₁(0)), tuple₂(T1, T2)) -> T1
element₂(int₁(s₁(s₁(N1))), tuple₂(T1, T2)) -> element₂(int₁(s₁(N1)), T2)
record_new₁(lock) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(undefined, tuple₂(nil, tuplenil₁(nil)))))
record_extract₃(tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2))))), lock, resource) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2)))))
record_update₄(tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2))))), lock, pending, NewF) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(NewF)))))
record_updates₃(Record, Name, nil) -> Record
record_updates₃(Record, Name, cons₂(tuple₂(Field, tuplenil₁(NewF)), Fields)) -> record_updates₃(record_update₄(Record, Name, Field, NewF), Name, Fields)
locker2_map_promote_pending₂(nil, Pending) -> nil
locker2_map_promote_pending₂(cons₂(Lock, Locks), Pending) -> cons₂(locker2_promote_pending₂(Lock, Pending), locker2_map_promote_pending₂(Locks, Pending))
locker2_map_claim_lock₃(nil, Resources, Client) -> nil
locker2_map_claim_lock₃(cons₂(Lock, Locks), Resources, Client) -> cons₂(locker2_claim_lock₃(Lock, Resources, Client), locker2_map_claim_lock₃(Locks, Resources, Client))
locker2_map_add_pending₃(nil, Resources, Client) -> nil
locker2_promote_pending₂(Lock, Client) -> case0₃(Client, Lock, record_extract₃(Lock, lock, pending))
case0₃(Client, Lock, cons₂(Client, Pendings)) -> record_updates₃(Lock, lock, cons₂(tuple₂(excl, tuplenil₁(Client)), cons₂(tuple₂(pending, tuplenil₁(Pendings)), nil)))
case0₃(Client, Lock, MCRLFree0) -> Lock
locker2_remove_pending₂(Lock, Client) -> record_updates₃(Lock, lock, cons₂(tuple₂(pending, tuplenil₁(subtract₂(record_extract₃(Lock, lock, pending), cons₂(Client, nil)))), nil))
locker2_add_pending₃(Lock, Resources, Client) -> case1₄(Client, Resources, Lock, member₂(record_extract₃(Lock, lock, resource), Resources))
case1₄(Client, Resources, Lock, true) -> record_updates₃(Lock, lock, cons₂(tuple₂(pending, tuplenil₁(append₂(record_extract₃(Lock, lock, pending), cons₂(Client, nil)))), nil))
case1₄(Client, Resources, Lock, false) -> Lock
locker2_release_lock₂(Lock, Client) -> case2₃(Client, Lock, gen_modtageq₂(Client, record_extract₃(Lock, lock, excl)))
case2₃(Client, Lock, true) -> record_updates₃(Lock, lock, cons₂(tuple₂(excllock, excl), nil))
case4₃(Client, Lock, MCRLFree1) -> false
locker2_obtainables₂(nil, Client) -> true
locker2_obtainables₂(cons₂(Lock, Locks), Client) -> case5₄(Client, Locks, Lock, member₂(Client, record_extract₃(Lock, lock, pending)))
case5₄(Client, Locks, Lock, true) -> andt₂(locker2_obtainable₂(Lock, Client), locker2_obtainables₂(Locks, Client))
case5₄(Client, Locks, Lock, false) -> locker2_obtainables₂(Locks, Client)
locker2_check_available₂(Resource, nil) -> false
locker2_check_available₂(Resource, cons₂(Lock, Locks)) -> case6₄(Locks, Lock, Resource, equal₂(Resource, record_extract₃(Lock, lock, resource)))
case6₄(Locks, Lock, Resource, true) -> andt₂(equal₂(record_extract₃(Lock, lock, excl), nil), equal₂(record_extract₃(Lock, lock, pending), nil))
case6₄(Locks, Lock, Resource, false) -> locker2_check_available₂(Resource, Locks)
locker2_check_availables₂(nil, Locks) -> true
locker2_check_availables₂(cons₂(Resource, Resources), Locks) -> andt₂(locker2_check_available₂(Resource, Locks), locker2_check_availables₂(Resources, Locks))
locker2_adduniq₂(nil, List) -> List
append₂(cons₂(Head, Tail), List) -> cons₂(Head, append₂(Tail, List))
subtract₂(List, nil) -> List
subtract₂(List, cons₂(Head, Tail)) -> subtract₂(delete₂(Head, List), Tail)
delete₂(E, nil) -> nil
delete₂(E, cons₂(Head, Tail)) -> case8₄(Tail, Head, E, equal₂(E, Head))
case8₄(Tail, Head, E, true) -> Tail
case8₄(Tail, Head, E, false) -> cons₂(Head, delete₂(E, Tail))
gen_tag₁(Pid) -> tuple₂(Pid, tuplenil₁(tag))
gen_modtageq₂(Client1, Client2) -> equal₂(Client1, Client2)
member₂(E, nil) -> false
member₂(E, cons₂(Head, Tail)) -> case9₄(Tail, Head, E, equal₂(E, Head))
case9₄(Tail, Head, E, true) -> true
case9₄(Tail, Head, E, false) -> member₂(E, Tail)
eqs₂(empty, empty) -> T
eqs₂(empty, stack₂(E2, S2)) -> F
eqs₂(stack₂(E1, S1), empty) -> F
eqs₂(stack₂(E1, S1), stack₂(E2, S2)) -> and₂(eqt₂(E1, E2), eqs₂(S1, S2))
pushs₂(E1, S1) -> stack₂(E1, S1)
pops₁(stack₂(E1, S1)) -> S1
tops₁(stack₂(E1, S1)) -> E1
istops₂(E1, empty) -> F
istops₂(E1, stack₂(E2, S1)) -> eqt₂(E1, E2)
eqc₂(nocalls, nocalls) -> T
eqc₂(nocalls, calls₃(E2, S2, CS2)) -> F
eqc₂(calls₃(E1, S1, CS1), nocalls) -> F
eqc₂(calls₃(E1, S1, CS1), calls₃(E2, S2, CS2)) -> and₂(eqt₂(E1, E2), and₂(eqs₂(S1, S2), eqc₂(CS1, CS2)))
push₃(E1, E2, nocalls) -> calls₃(E1, stack₂(E2, empty), nocalls)
push₃(E1, E2, calls₃(E3, S1, CS1)) -> push1₆(E1, E2, E3, S1, CS1, eqt₂(E1, E3))
push1₆(E1, E2, E3, S1, CS1, T) -> calls₃(E3, pushs₂(E2, S1), CS1)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

EQS₂(stack₂(E1, S1), stack₂(E2, S2)) -> EQS₂(S1, S2)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial Order [17,21] with Interpretation:

POL( stack₂(x₁, x₂) ) = x₁ + x₂ + 1

POL( EQS₂(x₁, x₂) ) = max{0, x₁ + x₂ - 1}

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ PisEmptyProof

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

or₂(T, T) -> T
or₂(F, T) -> T
or₂(T, F) -> T
or₂(F, F) -> F
and₂(T, B) -> B
and₂(B, T) -> B
and₂(F, B) -> F
and₂(B, F) -> F
imp₂(T, B) -> B
imp₂(F, B) -> T
not₁(T) -> F
not₁(F) -> T
if₃(T, B1, B2) -> B1
if₃(F, B1, B2) -> B2
eq₂(T, T) -> T
eq₂(F, F) -> T
eq₂(T, F) -> F
eq₂(F, T) -> F
eqt₂(nil, undefined) -> F
eqt₂(nil, pid₁(N2)) -> F
eqt₂(nil, int₁(N2)) -> F
eqt₂(nil, cons₂(H2, T2)) -> F
eqt₂(nil, tuple₂(H2, T2)) -> F
eqt₂(nil, tuplenil₁(H2)) -> F
eqt₂(a, nil) -> F
eqt₂(a, a) -> T
eqt₂(a, excl) -> F
eqt₂(a, false) -> F
eqt₂(a, lock) -> F
eqt₂(a, locker) -> F
eqt₂(a, mcrlrecord) -> F
eqt₂(a, ok) -> F
eqt₂(a, pending) -> F
eqt₂(a, release) -> F
eqt₂(a, request) -> F
eqt₂(a, resource) -> F
eqt₂(a, tag) -> F
eqt₂(a, true) -> F
eqt₂(a, undefined) -> F
eqt₂(a, pid₁(N2)) -> F
eqt₂(a, int₁(N2)) -> F
eqt₂(a, cons₂(H2, T2)) -> F
eqt₂(a, tuple₂(H2, T2)) -> F
eqt₂(a, tuplenil₁(H2)) -> F
eqt₂(excl, nil) -> F
eqt₂(excl, a) -> F
eqt₂(excl, excl) -> T
eqt₂(excl, false) -> F
eqt₂(excl, lock) -> F
eqt₂(excl, locker) -> F
eqt₂(excl, mcrlrecord) -> F
eqt₂(excl, ok) -> F
eqt₂(excl, pending) -> F
eqt₂(excl, release) -> F
eqt₂(excl, request) -> F
eqt₂(excl, resource) -> F
eqt₂(excl, tag) -> F
eqt₂(excl, true) -> F
eqt₂(excl, undefined) -> F
eqt₂(excl, pid₁(N2)) -> F
eqt₂(excl, eqt₂(false, int₁(N2))) -> F
eqt₂(false, cons₂(H2, T2)) -> F
eqt₂(false, tuple₂(H2, T2)) -> F
eqt₂(false, tuplenil₁(H2)) -> F
eqt₂(lock, nil) -> F
eqt₂(lock, a) -> F
eqt₂(lock, excl) -> F
eqt₂(lock, false) -> F
eqt₂(lock, lock) -> T
eqt₂(lock, locker) -> F
eqt₂(lock, mcrlrecord) -> F
eqt₂(lock, ok) -> F
eqt₂(lock, pending) -> F
eqt₂(lock, release) -> F
eqt₂(lock, request) -> F
eqt₂(lock, resource) -> F
eqt₂(lock, tag) -> F
eqt₂(lock, true) -> F
eqt₂(lock, undefined) -> F
eqt₂(lock, pid₁(N2)) -> F
eqt₂(lock, int₁(N2)) -> F
eqt₂(lock, cons₂(H2, T2)) -> F
eqt₂(lock, tuple₂(H2, T2)) -> F
eqt₂(lock, tuplenil₁(H2)) -> F
eqt₂(locker, nil) -> F
eqt₂(locker, a) -> F
eqt₂(locker, excl) -> F
eqt₂(locker, false) -> F
eqt₂(locker, lock) -> F
eqt₂(locker, locker) -> T
eqt₂(locker, mcrlrecord) -> F
eqt₂(locker, ok) -> F
eqt₂(locker, pending) -> F
eqt₂(locker, release) -> F
eqt₂(locker, request) -> F
eqt₂(locker, resource) -> F
eqt₂(locker, tag) -> F
eqt₂(locker, true) -> F
eqt₂(locker, undefined) -> F
eqt₂(locker, pid₁(N2)) -> F
eqt₂(locker, int₁(N2)) -> F
eqt₂(locker, cons₂(H2, T2)) -> F
eqt₂(locker, tuple₂(H2, T2)) -> F
eqt₂(locker, tuplenil₁(H2)) -> F
eqt₂(mcrlrecord, nil) -> F
eqt₂(mcrlrecord, a) -> F
eqt₂(mcrlrecord, excl) -> F
eqt₂(mcrlrecord, false) -> F
eqt₂(mcrlrecord, lock) -> F
eqt₂(mcrlrecord, locker) -> F
eqt₂(mcrlrecord, mcrlrecord) -> T
eqt₂(mcrlrecord, ok) -> F
eqt₂(mcrlrecord, pending) -> F
eqt₂(mcrlrecord, release) -> F
eqt₂(mcrlrecord, request) -> F
eqt₂(mcrlrecord, resource) -> F
eqt₂(ok, resource) -> F
eqt₂(ok, tag) -> F
eqt₂(ok, true) -> F
eqt₂(ok, undefined) -> F
eqt₂(ok, pid₁(N2)) -> F
eqt₂(ok, int₁(N2)) -> F
eqt₂(ok, cons₂(H2, T2)) -> F
eqt₂(ok, tuple₂(H2, T2)) -> F
eqt₂(ok, tuplenil₁(H2)) -> F
eqt₂(pending, nil) -> F
eqt₂(pending, a) -> F
eqt₂(pending, excl) -> F
eqt₂(pending, false) -> F
eqt₂(pending, lock) -> F
eqt₂(pending, locker) -> F
eqt₂(pending, mcrlrecord) -> F
eqt₂(pending, ok) -> F
eqt₂(pending, pending) -> T
eqt₂(pending, release) -> F
eqt₂(pending, request) -> F
eqt₂(pending, resource) -> F
eqt₂(pending, tag) -> F
eqt₂(pending, true) -> F
eqt₂(pending, undefined) -> F
eqt₂(pending, pid₁(N2)) -> F
eqt₂(pending, int₁(N2)) -> F
eqt₂(pending, cons₂(H2, T2)) -> F
eqt₂(pending, tuple₂(H2, T2)) -> F
eqt₂(pending, tuplenil₁(H2)) -> F
eqt₂(release, nil) -> F
eqt₂(release, a) -> F
eqt₂(release, excl) -> F
eqt₂(release, false) -> F
eqt₂(release, lock) -> F
eqt₂(release, locker) -> F
eqt₂(release, mcrlrecord) -> F
eqt₂(release, ok) -> F
eqt₂(request, mcrlrecord) -> F
eqt₂(request, ok) -> F
eqt₂(request, pending) -> F
eqt₂(request, release) -> F
eqt₂(request, request) -> T
eqt₂(request, resource) -> F
eqt₂(request, tag) -> F
eqt₂(request, true) -> F
eqt₂(request, undefined) -> F
eqt₂(request, pid₁(N2)) -> F
eqt₂(request, int₁(N2)) -> F
eqt₂(request, cons₂(H2, T2)) -> F
eqt₂(request, tuple₂(H2, T2)) -> F
eqt₂(request, tuplenil₁(H2)) -> F
eqt₂(resource, nil) -> F
eqt₂(resource, a) -> F
eqt₂(resource, excl) -> F
eqt₂(resource, false) -> F
eqt₂(resource, lock) -> F
eqt₂(resource, locker) -> F
eqt₂(resource, mcrlrecord) -> F
eqt₂(resource, ok) -> F
eqt₂(resource, pending) -> F
eqt₂(resource, release) -> F
eqt₂(resource, request) -> F
eqt₂(resource, resource) -> T
eqt₂(resource, tag) -> F
eqt₂(resource, true) -> F
eqt₂(resource, undefined) -> F
eqt₂(resource, pid₁(N2)) -> F
eqt₂(resource, int₁(N2)) -> F
eqt₂(resource, cons₂(H2, T2)) -> F
eqt₂(resource, tuple₂(H2, T2)) -> F
eqt₂(resource, tuplenil₁(H2)) -> F
eqt₂(tag, nil) -> F
eqt₂(tag, a) -> F
eqt₂(tag, excl) -> F
eqt₂(tag, false) -> F
eqt₂(tag, lock) -> F
eqt₂(tag, locker) -> F
eqt₂(tag, mcrlrecord) -> F
eqt₂(tag, ok) -> F
eqt₂(tag, pending) -> F
eqt₂(tag, release) -> F
eqt₂(tag, request) -> F
eqt₂(tag, resource) -> F
eqt₂(tag, tag) -> T
eqt₂(tag, true) -> F
eqt₂(tag, undefined) -> F
eqt₂(tag, pid₁(N2)) -> F
eqt₂(tag, int₁(N2)) -> F
eqt₂(tag, cons₂(H2, T2)) -> F
eqt₂(tag, tuple₂(H2, T2)) -> F
eqt₂(tag, tuplenil₁(H2)) -> F
eqt₂(true, nil) -> F
eqt₂(true, a) -> F
eqt₂(true, excl) -> F
eqt₂(true, false) -> F
eqt₂(true, lock) -> F
eqt₂(true, locker) -> F
eqt₂(true, mcrlrecord) -> F
eqt₂(true, ok) -> F
eqt₂(true, pending) -> F
eqt₂(true, release) -> F
eqt₂(true, request) -> F
eqt₂(true, resource) -> F
eqt₂(true, tag) -> F
eqt₂(true, true) -> T
eqt₂(true, undefined) -> F
eqt₂(true, pid₁(N2)) -> F
eqt₂(true, int₁(N2)) -> F
eqt₂(true, cons₂(H2, T2)) -> F
eqt₂(true, tuple₂(H2, T2)) -> F
eqt₂(true, tuplenil₁(H2)) -> F
eqt₂(undefined, nil) -> F
eqt₂(undefined, a) -> F
eqt₂(undefined, tuplenil₁(H2)) -> F
eqt₂(pid₁(N1), nil) -> F
eqt₂(pid₁(N1), a) -> F
eqt₂(pid₁(N1), excl) -> F
eqt₂(pid₁(N1), false) -> F
eqt₂(pid₁(N1), lock) -> F
eqt₂(pid₁(N1), locker) -> F
eqt₂(pid₁(N1), mcrlrecord) -> F
eqt₂(pid₁(N1), ok) -> F
eqt₂(pid₁(N1), pending) -> F
eqt₂(pid₁(N1), release) -> F
eqt₂(pid₁(N1), request) -> F
eqt₂(pid₁(N1), resource) -> F
eqt₂(pid₁(N1), tag) -> F
eqt₂(pid₁(N1), true) -> F
eqt₂(pid₁(N1), undefined) -> F
eqt₂(pid₁(N1), pid₁(N2)) -> eqt₂(N1, N2)
eqt₂(pid₁(N1), int₁(N2)) -> F
eqt₂(pid₁(N1), cons₂(H2, T2)) -> F
eqt₂(pid₁(N1), tuple₂(H2, T2)) -> F
eqt₂(pid₁(N1), tuplenil₁(H2)) -> F
eqt₂(int₁(N1), nil) -> F
eqt₂(int₁(N1), a) -> F
eqt₂(int₁(N1), excl) -> F
eqt₂(int₁(N1), false) -> F
eqt₂(int₁(N1), lock) -> F
eqt₂(int₁(N1), locker) -> F
eqt₂(int₁(N1), mcrlrecord) -> F
eqt₂(int₁(N1), ok) -> F
eqt₂(int₁(N1), pending) -> F
eqt₂(int₁(N1), release) -> F
eqt₂(int₁(N1), request) -> F
eqt₂(int₁(N1), resource) -> F
eqt₂(int₁(N1), tag) -> F
eqt₂(int₁(N1), true) -> F
eqt₂(int₁(N1), undefined) -> F
eqt₂(cons₂(H1, T1), resource) -> F
eqt₂(cons₂(H1, T1), tag) -> F
eqt₂(cons₂(H1, T1), true) -> F
eqt₂(cons₂(H1, T1), undefined) -> F
eqt₂(cons₂(H1, T1), pid₁(N2)) -> F
eqt₂(cons₂(H1, T1), int₁(N2)) -> F
eqt₂(cons₂(H1, T1), cons₂(H2, T2)) -> and₂(eqt₂(H1, H2), eqt₂(T1, T2))
eqt₂(cons₂(H1, T1), tuple₂(H2, T2)) -> F
eqt₂(cons₂(H1, T1), tuplenil₁(H2)) -> F
eqt₂(tuple₂(H1, T1), nil) -> F
eqt₂(tuple₂(H1, T1), a) -> F
eqt₂(tuple₂(H1, T1), excl) -> F
eqt₂(tuple₂(H1, T1), false) -> F
eqt₂(tuple₂(H1, T1), lock) -> F
eqt₂(tuple₂(H1, T1), locker) -> F
eqt₂(tuple₂(H1, T1), mcrlrecord) -> F
eqt₂(tuple₂(H1, T1), ok) -> F
eqt₂(tuple₂(H1, T1), pending) -> F
eqt₂(tuple₂(H1, T1), release) -> F
eqt₂(tuple₂(H1, T1), request) -> F
eqt₂(tuple₂(H1, T1), resource) -> F
eqt₂(tuple₂(H1, T1), tag) -> F
eqt₂(tuple₂(H1, T1), true) -> F
eqt₂(tuple₂(H1, T1), undefined) -> F
eqt₂(tuple₂(H1, T1), pid₁(N2)) -> F
eqt₂(tuple₂(H1, T1), int₁(N2)) -> F
eqt₂(tuple₂(H1, T1), cons₂(H2, T2)) -> F
eqt₂(tuple₂(H1, T1), tuple₂(H2, T2)) -> and₂(eqt₂(H1, H2), eqt₂(T1, T2))
eqt₂(tuple₂(H1, T1), tuplenil₁(H2)) -> F
eqt₂(tuplenil₁(H1), nil) -> F
eqt₂(tuplenil₁(H1), a) -> F
eqt₂(tuplenil₁(H1), excl) -> F
eqt₂(tuplenil₁(H1), false) -> F
eqt₂(tuplenil₁(H1), lock) -> F
eqt₂(tuplenil₁(H1), locker) -> F
eqt₂(tuplenil₁(H1), mcrlrecord) -> F
eqt₂(tuplenil₁(H1), ok) -> F
eqt₂(tuplenil₁(H1), pending) -> F
eqt₂(tuplenil₁(H1), release) -> F
eqt₂(tuplenil₁(H1), request) -> F
eqt₂(tuplenil₁(H1), resource) -> F
eqt₂(tuplenil₁(H1), tag) -> F
eqt₂(tuplenil₁(H1), true) -> F
eqt₂(tuplenil₁(H1), undefined) -> F
eqt₂(tuplenil₁(H1), pid₁(N2)) -> F
eqt₂(tuplenil₁(H1), int₁(N2)) -> F
eqt₂(tuplenil₁(H1), cons₂(H2, T2)) -> F
eqt₂(tuplenil₁(H1), tuple₂(H2, T2)) -> F
eqt₂(tuplenil₁(H1), tuplenil₁(H2)) -> eqt₂(H1, H2)
element₂(int₁(s₁(0)), tuplenil₁(T1)) -> T1
element₂(int₁(s₁(0)), tuple₂(T1, T2)) -> T1
element₂(int₁(s₁(s₁(N1))), tuple₂(T1, T2)) -> element₂(int₁(s₁(N1)), T2)
record_new₁(lock) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(undefined, tuple₂(nil, tuplenil₁(nil)))))
record_extract₃(tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2))))), lock, resource) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2)))))
record_update₄(tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2))))), lock, pending, NewF) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(NewF)))))
record_updates₃(Record, Name, nil) -> Record
record_updates₃(Record, Name, cons₂(tuple₂(Field, tuplenil₁(NewF)), Fields)) -> record_updates₃(record_update₄(Record, Name, Field, NewF), Name, Fields)
locker2_map_promote_pending₂(nil, Pending) -> nil
locker2_map_promote_pending₂(cons₂(Lock, Locks), Pending) -> cons₂(locker2_promote_pending₂(Lock, Pending), locker2_map_promote_pending₂(Locks, Pending))
locker2_map_claim_lock₃(nil, Resources, Client) -> nil
locker2_map_claim_lock₃(cons₂(Lock, Locks), Resources, Client) -> cons₂(locker2_claim_lock₃(Lock, Resources, Client), locker2_map_claim_lock₃(Locks, Resources, Client))
locker2_map_add_pending₃(nil, Resources, Client) -> nil
locker2_promote_pending₂(Lock, Client) -> case0₃(Client, Lock, record_extract₃(Lock, lock, pending))
case0₃(Client, Lock, cons₂(Client, Pendings)) -> record_updates₃(Lock, lock, cons₂(tuple₂(excl, tuplenil₁(Client)), cons₂(tuple₂(pending, tuplenil₁(Pendings)), nil)))
case0₃(Client, Lock, MCRLFree0) -> Lock
locker2_remove_pending₂(Lock, Client) -> record_updates₃(Lock, lock, cons₂(tuple₂(pending, tuplenil₁(subtract₂(record_extract₃(Lock, lock, pending), cons₂(Client, nil)))), nil))
locker2_add_pending₃(Lock, Resources, Client) -> case1₄(Client, Resources, Lock, member₂(record_extract₃(Lock, lock, resource), Resources))
case1₄(Client, Resources, Lock, true) -> record_updates₃(Lock, lock, cons₂(tuple₂(pending, tuplenil₁(append₂(record_extract₃(Lock, lock, pending), cons₂(Client, nil)))), nil))
case1₄(Client, Resources, Lock, false) -> Lock
locker2_release_lock₂(Lock, Client) -> case2₃(Client, Lock, gen_modtageq₂(Client, record_extract₃(Lock, lock, excl)))
case2₃(Client, Lock, true) -> record_updates₃(Lock, lock, cons₂(tuple₂(excllock, excl), nil))
case4₃(Client, Lock, MCRLFree1) -> false
locker2_obtainables₂(nil, Client) -> true
locker2_obtainables₂(cons₂(Lock, Locks), Client) -> case5₄(Client, Locks, Lock, member₂(Client, record_extract₃(Lock, lock, pending)))
case5₄(Client, Locks, Lock, true) -> andt₂(locker2_obtainable₂(Lock, Client), locker2_obtainables₂(Locks, Client))
case5₄(Client, Locks, Lock, false) -> locker2_obtainables₂(Locks, Client)
locker2_check_available₂(Resource, nil) -> false
locker2_check_available₂(Resource, cons₂(Lock, Locks)) -> case6₄(Locks, Lock, Resource, equal₂(Resource, record_extract₃(Lock, lock, resource)))
case6₄(Locks, Lock, Resource, true) -> andt₂(equal₂(record_extract₃(Lock, lock, excl), nil), equal₂(record_extract₃(Lock, lock, pending), nil))
case6₄(Locks, Lock, Resource, false) -> locker2_check_available₂(Resource, Locks)
locker2_check_availables₂(nil, Locks) -> true
locker2_check_availables₂(cons₂(Resource, Resources), Locks) -> andt₂(locker2_check_available₂(Resource, Locks), locker2_check_availables₂(Resources, Locks))
locker2_adduniq₂(nil, List) -> List
append₂(cons₂(Head, Tail), List) -> cons₂(Head, append₂(Tail, List))
subtract₂(List, nil) -> List
subtract₂(List, cons₂(Head, Tail)) -> subtract₂(delete₂(Head, List), Tail)
delete₂(E, nil) -> nil
delete₂(E, cons₂(Head, Tail)) -> case8₄(Tail, Head, E, equal₂(E, Head))
case8₄(Tail, Head, E, true) -> Tail
case8₄(Tail, Head, E, false) -> cons₂(Head, delete₂(E, Tail))
gen_tag₁(Pid) -> tuple₂(Pid, tuplenil₁(tag))
gen_modtageq₂(Client1, Client2) -> equal₂(Client1, Client2)
member₂(E, nil) -> false
member₂(E, cons₂(Head, Tail)) -> case9₄(Tail, Head, E, equal₂(E, Head))
case9₄(Tail, Head, E, true) -> true
case9₄(Tail, Head, E, false) -> member₂(E, Tail)
eqs₂(empty, empty) -> T
eqs₂(empty, stack₂(E2, S2)) -> F
eqs₂(stack₂(E1, S1), empty) -> F
eqs₂(stack₂(E1, S1), stack₂(E2, S2)) -> and₂(eqt₂(E1, E2), eqs₂(S1, S2))
pushs₂(E1, S1) -> stack₂(E1, S1)
pops₁(stack₂(E1, S1)) -> S1
tops₁(stack₂(E1, S1)) -> E1
istops₂(E1, empty) -> F
istops₂(E1, stack₂(E2, S1)) -> eqt₂(E1, E2)
eqc₂(nocalls, nocalls) -> T
eqc₂(nocalls, calls₃(E2, S2, CS2)) -> F
eqc₂(calls₃(E1, S1, CS1), nocalls) -> F
eqc₂(calls₃(E1, S1, CS1), calls₃(E2, S2, CS2)) -> and₂(eqt₂(E1, E2), and₂(eqs₂(S1, S2), eqc₂(CS1, CS2)))
push₃(E1, E2, nocalls) -> calls₃(E1, stack₂(E2, empty), nocalls)
push₃(E1, E2, calls₃(E3, S1, CS1)) -> push1₆(E1, E2, E3, S1, CS1, eqt₂(E1, E3))
push1₆(E1, E2, E3, S1, CS1, T) -> calls₃(E3, pushs₂(E2, S1), CS1)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

Q DP problem:
The TRS P consists of the following rules:

EQC₂(calls₃(E1, S1, CS1), calls₃(E2, S2, CS2)) -> EQC₂(CS1, CS2)

The TRS R consists of the following rules:

or₂(T, T) -> T
or₂(F, T) -> T
or₂(T, F) -> T
or₂(F, F) -> F
and₂(T, B) -> B
and₂(B, T) -> B
and₂(F, B) -> F
and₂(B, F) -> F
imp₂(T, B) -> B
imp₂(F, B) -> T
not₁(T) -> F
not₁(F) -> T
if₃(T, B1, B2) -> B1
if₃(F, B1, B2) -> B2
eq₂(T, T) -> T
eq₂(F, F) -> T
eq₂(T, F) -> F
eq₂(F, T) -> F
eqt₂(nil, undefined) -> F
eqt₂(nil, pid₁(N2)) -> F
eqt₂(nil, int₁(N2)) -> F
eqt₂(nil, cons₂(H2, T2)) -> F
eqt₂(nil, tuple₂(H2, T2)) -> F
eqt₂(nil, tuplenil₁(H2)) -> F
eqt₂(a, nil) -> F
eqt₂(a, a) -> T
eqt₂(a, excl) -> F
eqt₂(a, false) -> F
eqt₂(a, lock) -> F
eqt₂(a, locker) -> F
eqt₂(a, mcrlrecord) -> F
eqt₂(a, ok) -> F
eqt₂(a, pending) -> F
eqt₂(a, release) -> F
eqt₂(a, request) -> F
eqt₂(a, resource) -> F
eqt₂(a, tag) -> F
eqt₂(a, true) -> F
eqt₂(a, undefined) -> F
eqt₂(a, pid₁(N2)) -> F
eqt₂(a, int₁(N2)) -> F
eqt₂(a, cons₂(H2, T2)) -> F
eqt₂(a, tuple₂(H2, T2)) -> F
eqt₂(a, tuplenil₁(H2)) -> F
eqt₂(excl, nil) -> F
eqt₂(excl, a) -> F
eqt₂(excl, excl) -> T
eqt₂(excl, false) -> F
eqt₂(excl, lock) -> F
eqt₂(excl, locker) -> F
eqt₂(excl, mcrlrecord) -> F
eqt₂(excl, ok) -> F
eqt₂(excl, pending) -> F
eqt₂(excl, release) -> F
eqt₂(excl, request) -> F
eqt₂(excl, resource) -> F
eqt₂(excl, tag) -> F
eqt₂(excl, true) -> F
eqt₂(excl, undefined) -> F
eqt₂(excl, pid₁(N2)) -> F
eqt₂(excl, eqt₂(false, int₁(N2))) -> F
eqt₂(false, cons₂(H2, T2)) -> F
eqt₂(false, tuple₂(H2, T2)) -> F
eqt₂(false, tuplenil₁(H2)) -> F
eqt₂(lock, nil) -> F
eqt₂(lock, a) -> F
eqt₂(lock, excl) -> F
eqt₂(lock, false) -> F
eqt₂(lock, lock) -> T
eqt₂(lock, locker) -> F
eqt₂(lock, mcrlrecord) -> F
eqt₂(lock, ok) -> F
eqt₂(lock, pending) -> F
eqt₂(lock, release) -> F
eqt₂(lock, request) -> F
eqt₂(lock, resource) -> F
eqt₂(lock, tag) -> F
eqt₂(lock, true) -> F
eqt₂(lock, undefined) -> F
eqt₂(lock, pid₁(N2)) -> F
eqt₂(lock, int₁(N2)) -> F
eqt₂(lock, cons₂(H2, T2)) -> F
eqt₂(lock, tuple₂(H2, T2)) -> F
eqt₂(lock, tuplenil₁(H2)) -> F
eqt₂(locker, nil) -> F
eqt₂(locker, a) -> F
eqt₂(locker, excl) -> F
eqt₂(locker, false) -> F
eqt₂(locker, lock) -> F
eqt₂(locker, locker) -> T
eqt₂(locker, mcrlrecord) -> F
eqt₂(locker, ok) -> F
eqt₂(locker, pending) -> F
eqt₂(locker, release) -> F
eqt₂(locker, request) -> F
eqt₂(locker, resource) -> F
eqt₂(locker, tag) -> F
eqt₂(locker, true) -> F
eqt₂(locker, undefined) -> F
eqt₂(locker, pid₁(N2)) -> F
eqt₂(locker, int₁(N2)) -> F
eqt₂(locker, cons₂(H2, T2)) -> F
eqt₂(locker, tuple₂(H2, T2)) -> F
eqt₂(locker, tuplenil₁(H2)) -> F
eqt₂(mcrlrecord, nil) -> F
eqt₂(mcrlrecord, a) -> F
eqt₂(mcrlrecord, excl) -> F
eqt₂(mcrlrecord, false) -> F
eqt₂(mcrlrecord, lock) -> F
eqt₂(mcrlrecord, locker) -> F
eqt₂(mcrlrecord, mcrlrecord) -> T
eqt₂(mcrlrecord, ok) -> F
eqt₂(mcrlrecord, pending) -> F
eqt₂(mcrlrecord, release) -> F
eqt₂(mcrlrecord, request) -> F
eqt₂(mcrlrecord, resource) -> F
eqt₂(ok, resource) -> F
eqt₂(ok, tag) -> F
eqt₂(ok, true) -> F
eqt₂(ok, undefined) -> F
eqt₂(ok, pid₁(N2)) -> F
eqt₂(ok, int₁(N2)) -> F
eqt₂(ok, cons₂(H2, T2)) -> F
eqt₂(ok, tuple₂(H2, T2)) -> F
eqt₂(ok, tuplenil₁(H2)) -> F
eqt₂(pending, nil) -> F
eqt₂(pending, a) -> F
eqt₂(pending, excl) -> F
eqt₂(pending, false) -> F
eqt₂(pending, lock) -> F
eqt₂(pending, locker) -> F
eqt₂(pending, mcrlrecord) -> F
eqt₂(pending, ok) -> F
eqt₂(pending, pending) -> T
eqt₂(pending, release) -> F
eqt₂(pending, request) -> F
eqt₂(pending, resource) -> F
eqt₂(pending, tag) -> F
eqt₂(pending, true) -> F
eqt₂(pending, undefined) -> F
eqt₂(pending, pid₁(N2)) -> F
eqt₂(pending, int₁(N2)) -> F
eqt₂(pending, cons₂(H2, T2)) -> F
eqt₂(pending, tuple₂(H2, T2)) -> F
eqt₂(pending, tuplenil₁(H2)) -> F
eqt₂(release, nil) -> F
eqt₂(release, a) -> F
eqt₂(release, excl) -> F
eqt₂(release, false) -> F
eqt₂(release, lock) -> F
eqt₂(release, locker) -> F
eqt₂(release, mcrlrecord) -> F
eqt₂(release, ok) -> F
eqt₂(request, mcrlrecord) -> F
eqt₂(request, ok) -> F
eqt₂(request, pending) -> F
eqt₂(request, release) -> F
eqt₂(request, request) -> T
eqt₂(request, resource) -> F
eqt₂(request, tag) -> F
eqt₂(request, true) -> F
eqt₂(request, undefined) -> F
eqt₂(request, pid₁(N2)) -> F
eqt₂(request, int₁(N2)) -> F
eqt₂(request, cons₂(H2, T2)) -> F
eqt₂(request, tuple₂(H2, T2)) -> F
eqt₂(request, tuplenil₁(H2)) -> F
eqt₂(resource, nil) -> F
eqt₂(resource, a) -> F
eqt₂(resource, excl) -> F
eqt₂(resource, false) -> F
eqt₂(resource, lock) -> F
eqt₂(resource, locker) -> F
eqt₂(resource, mcrlrecord) -> F
eqt₂(resource, ok) -> F
eqt₂(resource, pending) -> F
eqt₂(resource, release) -> F
eqt₂(resource, request) -> F
eqt₂(resource, resource) -> T
eqt₂(resource, tag) -> F
eqt₂(resource, true) -> F
eqt₂(resource, undefined) -> F
eqt₂(resource, pid₁(N2)) -> F
eqt₂(resource, int₁(N2)) -> F
eqt₂(resource, cons₂(H2, T2)) -> F
eqt₂(resource, tuple₂(H2, T2)) -> F
eqt₂(resource, tuplenil₁(H2)) -> F
eqt₂(tag, nil) -> F
eqt₂(tag, a) -> F
eqt₂(tag, excl) -> F
eqt₂(tag, false) -> F
eqt₂(tag, lock) -> F
eqt₂(tag, locker) -> F
eqt₂(tag, mcrlrecord) -> F
eqt₂(tag, ok) -> F
eqt₂(tag, pending) -> F
eqt₂(tag, release) -> F
eqt₂(tag, request) -> F
eqt₂(tag, resource) -> F
eqt₂(tag, tag) -> T
eqt₂(tag, true) -> F
eqt₂(tag, undefined) -> F
eqt₂(tag, pid₁(N2)) -> F
eqt₂(tag, int₁(N2)) -> F
eqt₂(tag, cons₂(H2, T2)) -> F
eqt₂(tag, tuple₂(H2, T2)) -> F
eqt₂(tag, tuplenil₁(H2)) -> F
eqt₂(true, nil) -> F
eqt₂(true, a) -> F
eqt₂(true, excl) -> F
eqt₂(true, false) -> F
eqt₂(true, lock) -> F
eqt₂(true, locker) -> F
eqt₂(true, mcrlrecord) -> F
eqt₂(true, ok) -> F
eqt₂(true, pending) -> F
eqt₂(true, release) -> F
eqt₂(true, request) -> F
eqt₂(true, resource) -> F
eqt₂(true, tag) -> F
eqt₂(true, true) -> T
eqt₂(true, undefined) -> F
eqt₂(true, pid₁(N2)) -> F
eqt₂(true, int₁(N2)) -> F
eqt₂(true, cons₂(H2, T2)) -> F
eqt₂(true, tuple₂(H2, T2)) -> F
eqt₂(true, tuplenil₁(H2)) -> F
eqt₂(undefined, nil) -> F
eqt₂(undefined, a) -> F
eqt₂(undefined, tuplenil₁(H2)) -> F
eqt₂(pid₁(N1), nil) -> F
eqt₂(pid₁(N1), a) -> F
eqt₂(pid₁(N1), excl) -> F
eqt₂(pid₁(N1), false) -> F
eqt₂(pid₁(N1), lock) -> F
eqt₂(pid₁(N1), locker) -> F
eqt₂(pid₁(N1), mcrlrecord) -> F
eqt₂(pid₁(N1), ok) -> F
eqt₂(pid₁(N1), pending) -> F
eqt₂(pid₁(N1), release) -> F
eqt₂(pid₁(N1), request) -> F
eqt₂(pid₁(N1), resource) -> F
eqt₂(pid₁(N1), tag) -> F
eqt₂(pid₁(N1), true) -> F
eqt₂(pid₁(N1), undefined) -> F
eqt₂(pid₁(N1), pid₁(N2)) -> eqt₂(N1, N2)
eqt₂(pid₁(N1), int₁(N2)) -> F
eqt₂(pid₁(N1), cons₂(H2, T2)) -> F
eqt₂(pid₁(N1), tuple₂(H2, T2)) -> F
eqt₂(pid₁(N1), tuplenil₁(H2)) -> F
eqt₂(int₁(N1), nil) -> F
eqt₂(int₁(N1), a) -> F
eqt₂(int₁(N1), excl) -> F
eqt₂(int₁(N1), false) -> F
eqt₂(int₁(N1), lock) -> F
eqt₂(int₁(N1), locker) -> F
eqt₂(int₁(N1), mcrlrecord) -> F
eqt₂(int₁(N1), ok) -> F
eqt₂(int₁(N1), pending) -> F
eqt₂(int₁(N1), release) -> F
eqt₂(int₁(N1), request) -> F
eqt₂(int₁(N1), resource) -> F
eqt₂(int₁(N1), tag) -> F
eqt₂(int₁(N1), true) -> F
eqt₂(int₁(N1), undefined) -> F
eqt₂(cons₂(H1, T1), resource) -> F
eqt₂(cons₂(H1, T1), tag) -> F
eqt₂(cons₂(H1, T1), true) -> F
eqt₂(cons₂(H1, T1), undefined) -> F
eqt₂(cons₂(H1, T1), pid₁(N2)) -> F
eqt₂(cons₂(H1, T1), int₁(N2)) -> F
eqt₂(cons₂(H1, T1), cons₂(H2, T2)) -> and₂(eqt₂(H1, H2), eqt₂(T1, T2))
eqt₂(cons₂(H1, T1), tuple₂(H2, T2)) -> F
eqt₂(cons₂(H1, T1), tuplenil₁(H2)) -> F
eqt₂(tuple₂(H1, T1), nil) -> F
eqt₂(tuple₂(H1, T1), a) -> F
eqt₂(tuple₂(H1, T1), excl) -> F
eqt₂(tuple₂(H1, T1), false) -> F
eqt₂(tuple₂(H1, T1), lock) -> F
eqt₂(tuple₂(H1, T1), locker) -> F
eqt₂(tuple₂(H1, T1), mcrlrecord) -> F
eqt₂(tuple₂(H1, T1), ok) -> F
eqt₂(tuple₂(H1, T1), pending) -> F
eqt₂(tuple₂(H1, T1), release) -> F
eqt₂(tuple₂(H1, T1), request) -> F
eqt₂(tuple₂(H1, T1), resource) -> F
eqt₂(tuple₂(H1, T1), tag) -> F
eqt₂(tuple₂(H1, T1), true) -> F
eqt₂(tuple₂(H1, T1), undefined) -> F
eqt₂(tuple₂(H1, T1), pid₁(N2)) -> F
eqt₂(tuple₂(H1, T1), int₁(N2)) -> F
eqt₂(tuple₂(H1, T1), cons₂(H2, T2)) -> F
eqt₂(tuple₂(H1, T1), tuple₂(H2, T2)) -> and₂(eqt₂(H1, H2), eqt₂(T1, T2))
eqt₂(tuple₂(H1, T1), tuplenil₁(H2)) -> F
eqt₂(tuplenil₁(H1), nil) -> F
eqt₂(tuplenil₁(H1), a) -> F
eqt₂(tuplenil₁(H1), excl) -> F
eqt₂(tuplenil₁(H1), false) -> F
eqt₂(tuplenil₁(H1), lock) -> F
eqt₂(tuplenil₁(H1), locker) -> F
eqt₂(tuplenil₁(H1), mcrlrecord) -> F
eqt₂(tuplenil₁(H1), ok) -> F
eqt₂(tuplenil₁(H1), pending) -> F
eqt₂(tuplenil₁(H1), release) -> F
eqt₂(tuplenil₁(H1), request) -> F
eqt₂(tuplenil₁(H1), resource) -> F
eqt₂(tuplenil₁(H1), tag) -> F
eqt₂(tuplenil₁(H1), true) -> F
eqt₂(tuplenil₁(H1), undefined) -> F
eqt₂(tuplenil₁(H1), pid₁(N2)) -> F
eqt₂(tuplenil₁(H1), int₁(N2)) -> F
eqt₂(tuplenil₁(H1), cons₂(H2, T2)) -> F
eqt₂(tuplenil₁(H1), tuple₂(H2, T2)) -> F
eqt₂(tuplenil₁(H1), tuplenil₁(H2)) -> eqt₂(H1, H2)
element₂(int₁(s₁(0)), tuplenil₁(T1)) -> T1
element₂(int₁(s₁(0)), tuple₂(T1, T2)) -> T1
element₂(int₁(s₁(s₁(N1))), tuple₂(T1, T2)) -> element₂(int₁(s₁(N1)), T2)
record_new₁(lock) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(undefined, tuple₂(nil, tuplenil₁(nil)))))
record_extract₃(tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2))))), lock, resource) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2)))))
record_update₄(tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2))))), lock, pending, NewF) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(NewF)))))
record_updates₃(Record, Name, nil) -> Record
record_updates₃(Record, Name, cons₂(tuple₂(Field, tuplenil₁(NewF)), Fields)) -> record_updates₃(record_update₄(Record, Name, Field, NewF), Name, Fields)
locker2_map_promote_pending₂(nil, Pending) -> nil
locker2_map_promote_pending₂(cons₂(Lock, Locks), Pending) -> cons₂(locker2_promote_pending₂(Lock, Pending), locker2_map_promote_pending₂(Locks, Pending))
locker2_map_claim_lock₃(nil, Resources, Client) -> nil
locker2_map_claim_lock₃(cons₂(Lock, Locks), Resources, Client) -> cons₂(locker2_claim_lock₃(Lock, Resources, Client), locker2_map_claim_lock₃(Locks, Resources, Client))
locker2_map_add_pending₃(nil, Resources, Client) -> nil
locker2_promote_pending₂(Lock, Client) -> case0₃(Client, Lock, record_extract₃(Lock, lock, pending))
case0₃(Client, Lock, cons₂(Client, Pendings)) -> record_updates₃(Lock, lock, cons₂(tuple₂(excl, tuplenil₁(Client)), cons₂(tuple₂(pending, tuplenil₁(Pendings)), nil)))
case0₃(Client, Lock, MCRLFree0) -> Lock
locker2_remove_pending₂(Lock, Client) -> record_updates₃(Lock, lock, cons₂(tuple₂(pending, tuplenil₁(subtract₂(record_extract₃(Lock, lock, pending), cons₂(Client, nil)))), nil))
locker2_add_pending₃(Lock, Resources, Client) -> case1₄(Client, Resources, Lock, member₂(record_extract₃(Lock, lock, resource), Resources))
case1₄(Client, Resources, Lock, true) -> record_updates₃(Lock, lock, cons₂(tuple₂(pending, tuplenil₁(append₂(record_extract₃(Lock, lock, pending), cons₂(Client, nil)))), nil))
case1₄(Client, Resources, Lock, false) -> Lock
locker2_release_lock₂(Lock, Client) -> case2₃(Client, Lock, gen_modtageq₂(Client, record_extract₃(Lock, lock, excl)))
case2₃(Client, Lock, true) -> record_updates₃(Lock, lock, cons₂(tuple₂(excllock, excl), nil))
case4₃(Client, Lock, MCRLFree1) -> false
locker2_obtainables₂(nil, Client) -> true
locker2_obtainables₂(cons₂(Lock, Locks), Client) -> case5₄(Client, Locks, Lock, member₂(Client, record_extract₃(Lock, lock, pending)))
case5₄(Client, Locks, Lock, true) -> andt₂(locker2_obtainable₂(Lock, Client), locker2_obtainables₂(Locks, Client))
case5₄(Client, Locks, Lock, false) -> locker2_obtainables₂(Locks, Client)
locker2_check_available₂(Resource, nil) -> false
locker2_check_available₂(Resource, cons₂(Lock, Locks)) -> case6₄(Locks, Lock, Resource, equal₂(Resource, record_extract₃(Lock, lock, resource)))
case6₄(Locks, Lock, Resource, true) -> andt₂(equal₂(record_extract₃(Lock, lock, excl), nil), equal₂(record_extract₃(Lock, lock, pending), nil))
case6₄(Locks, Lock, Resource, false) -> locker2_check_available₂(Resource, Locks)
locker2_check_availables₂(nil, Locks) -> true
locker2_check_availables₂(cons₂(Resource, Resources), Locks) -> andt₂(locker2_check_available₂(Resource, Locks), locker2_check_availables₂(Resources, Locks))
locker2_adduniq₂(nil, List) -> List
append₂(cons₂(Head, Tail), List) -> cons₂(Head, append₂(Tail, List))
subtract₂(List, nil) -> List
subtract₂(List, cons₂(Head, Tail)) -> subtract₂(delete₂(Head, List), Tail)
delete₂(E, nil) -> nil
delete₂(E, cons₂(Head, Tail)) -> case8₄(Tail, Head, E, equal₂(E, Head))
case8₄(Tail, Head, E, true) -> Tail
case8₄(Tail, Head, E, false) -> cons₂(Head, delete₂(E, Tail))
gen_tag₁(Pid) -> tuple₂(Pid, tuplenil₁(tag))
gen_modtageq₂(Client1, Client2) -> equal₂(Client1, Client2)
member₂(E, nil) -> false
member₂(E, cons₂(Head, Tail)) -> case9₄(Tail, Head, E, equal₂(E, Head))
case9₄(Tail, Head, E, true) -> true
case9₄(Tail, Head, E, false) -> member₂(E, Tail)
eqs₂(empty, empty) -> T
eqs₂(empty, stack₂(E2, S2)) -> F
eqs₂(stack₂(E1, S1), empty) -> F
eqs₂(stack₂(E1, S1), stack₂(E2, S2)) -> and₂(eqt₂(E1, E2), eqs₂(S1, S2))
pushs₂(E1, S1) -> stack₂(E1, S1)
pops₁(stack₂(E1, S1)) -> S1
tops₁(stack₂(E1, S1)) -> E1
istops₂(E1, empty) -> F
istops₂(E1, stack₂(E2, S1)) -> eqt₂(E1, E2)
eqc₂(nocalls, nocalls) -> T
eqc₂(nocalls, calls₃(E2, S2, CS2)) -> F
eqc₂(calls₃(E1, S1, CS1), nocalls) -> F
eqc₂(calls₃(E1, S1, CS1), calls₃(E2, S2, CS2)) -> and₂(eqt₂(E1, E2), and₂(eqs₂(S1, S2), eqc₂(CS1, CS2)))
push₃(E1, E2, nocalls) -> calls₃(E1, stack₂(E2, empty), nocalls)
push₃(E1, E2, calls₃(E3, S1, CS1)) -> push1₆(E1, E2, E3, S1, CS1, eqt₂(E1, E3))
push1₆(E1, E2, E3, S1, CS1, T) -> calls₃(E3, pushs₂(E2, S1), CS1)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

EQC₂(calls₃(E1, S1, CS1), calls₃(E2, S2, CS2)) -> EQC₂(CS1, CS2)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial Order [17,21] with Interpretation:

POL( calls₃(x₁, ..., x₃) ) = x₁ + x₂ + x₃ + 1

POL( EQC₂(x₁, x₂) ) = x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ PisEmptyProof

Q DP problem:
P is empty.
The TRS R consists of the following rules:

or₂(T, T) -> T
or₂(F, T) -> T
or₂(T, F) -> T
or₂(F, F) -> F
and₂(T, B) -> B
and₂(B, T) -> B
and₂(F, B) -> F
and₂(B, F) -> F
imp₂(T, B) -> B
imp₂(F, B) -> T
not₁(T) -> F
not₁(F) -> T
if₃(T, B1, B2) -> B1
if₃(F, B1, B2) -> B2
eq₂(T, T) -> T
eq₂(F, F) -> T
eq₂(T, F) -> F
eq₂(F, T) -> F
eqt₂(nil, undefined) -> F
eqt₂(nil, pid₁(N2)) -> F
eqt₂(nil, int₁(N2)) -> F
eqt₂(nil, cons₂(H2, T2)) -> F
eqt₂(nil, tuple₂(H2, T2)) -> F
eqt₂(nil, tuplenil₁(H2)) -> F
eqt₂(a, nil) -> F
eqt₂(a, a) -> T
eqt₂(a, excl) -> F
eqt₂(a, false) -> F
eqt₂(a, lock) -> F
eqt₂(a, locker) -> F
eqt₂(a, mcrlrecord) -> F
eqt₂(a, ok) -> F
eqt₂(a, pending) -> F
eqt₂(a, release) -> F
eqt₂(a, request) -> F
eqt₂(a, resource) -> F
eqt₂(a, tag) -> F
eqt₂(a, true) -> F
eqt₂(a, undefined) -> F
eqt₂(a, pid₁(N2)) -> F
eqt₂(a, int₁(N2)) -> F
eqt₂(a, cons₂(H2, T2)) -> F
eqt₂(a, tuple₂(H2, T2)) -> F
eqt₂(a, tuplenil₁(H2)) -> F
eqt₂(excl, nil) -> F
eqt₂(excl, a) -> F
eqt₂(excl, excl) -> T
eqt₂(excl, false) -> F
eqt₂(excl, lock) -> F
eqt₂(excl, locker) -> F
eqt₂(excl, mcrlrecord) -> F
eqt₂(excl, ok) -> F
eqt₂(excl, pending) -> F
eqt₂(excl, release) -> F
eqt₂(excl, request) -> F
eqt₂(excl, resource) -> F
eqt₂(excl, tag) -> F
eqt₂(excl, true) -> F
eqt₂(excl, undefined) -> F
eqt₂(excl, pid₁(N2)) -> F
eqt₂(excl, eqt₂(false, int₁(N2))) -> F
eqt₂(false, cons₂(H2, T2)) -> F
eqt₂(false, tuple₂(H2, T2)) -> F
eqt₂(false, tuplenil₁(H2)) -> F
eqt₂(lock, nil) -> F
eqt₂(lock, a) -> F
eqt₂(lock, excl) -> F
eqt₂(lock, false) -> F
eqt₂(lock, lock) -> T
eqt₂(lock, locker) -> F
eqt₂(lock, mcrlrecord) -> F
eqt₂(lock, ok) -> F
eqt₂(lock, pending) -> F
eqt₂(lock, release) -> F
eqt₂(lock, request) -> F
eqt₂(lock, resource) -> F
eqt₂(lock, tag) -> F
eqt₂(lock, true) -> F
eqt₂(lock, undefined) -> F
eqt₂(lock, pid₁(N2)) -> F
eqt₂(lock, int₁(N2)) -> F
eqt₂(lock, cons₂(H2, T2)) -> F
eqt₂(lock, tuple₂(H2, T2)) -> F
eqt₂(lock, tuplenil₁(H2)) -> F
eqt₂(locker, nil) -> F
eqt₂(locker, a) -> F
eqt₂(locker, excl) -> F
eqt₂(locker, false) -> F
eqt₂(locker, lock) -> F
eqt₂(locker, locker) -> T
eqt₂(locker, mcrlrecord) -> F
eqt₂(locker, ok) -> F
eqt₂(locker, pending) -> F
eqt₂(locker, release) -> F
eqt₂(locker, request) -> F
eqt₂(locker, resource) -> F
eqt₂(locker, tag) -> F
eqt₂(locker, true) -> F
eqt₂(locker, undefined) -> F
eqt₂(locker, pid₁(N2)) -> F
eqt₂(locker, int₁(N2)) -> F
eqt₂(locker, cons₂(H2, T2)) -> F
eqt₂(locker, tuple₂(H2, T2)) -> F
eqt₂(locker, tuplenil₁(H2)) -> F
eqt₂(mcrlrecord, nil) -> F
eqt₂(mcrlrecord, a) -> F
eqt₂(mcrlrecord, excl) -> F
eqt₂(mcrlrecord, false) -> F
eqt₂(mcrlrecord, lock) -> F
eqt₂(mcrlrecord, locker) -> F
eqt₂(mcrlrecord, mcrlrecord) -> T
eqt₂(mcrlrecord, ok) -> F
eqt₂(mcrlrecord, pending) -> F
eqt₂(mcrlrecord, release) -> F
eqt₂(mcrlrecord, request) -> F
eqt₂(mcrlrecord, resource) -> F
eqt₂(ok, resource) -> F
eqt₂(ok, tag) -> F
eqt₂(ok, true) -> F
eqt₂(ok, undefined) -> F
eqt₂(ok, pid₁(N2)) -> F
eqt₂(ok, int₁(N2)) -> F
eqt₂(ok, cons₂(H2, T2)) -> F
eqt₂(ok, tuple₂(H2, T2)) -> F
eqt₂(ok, tuplenil₁(H2)) -> F
eqt₂(pending, nil) -> F
eqt₂(pending, a) -> F
eqt₂(pending, excl) -> F
eqt₂(pending, false) -> F
eqt₂(pending, lock) -> F
eqt₂(pending, locker) -> F
eqt₂(pending, mcrlrecord) -> F
eqt₂(pending, ok) -> F
eqt₂(pending, pending) -> T
eqt₂(pending, release) -> F
eqt₂(pending, request) -> F
eqt₂(pending, resource) -> F
eqt₂(pending, tag) -> F
eqt₂(pending, true) -> F
eqt₂(pending, undefined) -> F
eqt₂(pending, pid₁(N2)) -> F
eqt₂(pending, int₁(N2)) -> F
eqt₂(pending, cons₂(H2, T2)) -> F
eqt₂(pending, tuple₂(H2, T2)) -> F
eqt₂(pending, tuplenil₁(H2)) -> F
eqt₂(release, nil) -> F
eqt₂(release, a) -> F
eqt₂(release, excl) -> F
eqt₂(release, false) -> F
eqt₂(release, lock) -> F
eqt₂(release, locker) -> F
eqt₂(release, mcrlrecord) -> F
eqt₂(release, ok) -> F
eqt₂(request, mcrlrecord) -> F
eqt₂(request, ok) -> F
eqt₂(request, pending) -> F
eqt₂(request, release) -> F
eqt₂(request, request) -> T
eqt₂(request, resource) -> F
eqt₂(request, tag) -> F
eqt₂(request, true) -> F
eqt₂(request, undefined) -> F
eqt₂(request, pid₁(N2)) -> F
eqt₂(request, int₁(N2)) -> F
eqt₂(request, cons₂(H2, T2)) -> F
eqt₂(request, tuple₂(H2, T2)) -> F
eqt₂(request, tuplenil₁(H2)) -> F
eqt₂(resource, nil) -> F
eqt₂(resource, a) -> F
eqt₂(resource, excl) -> F
eqt₂(resource, false) -> F
eqt₂(resource, lock) -> F
eqt₂(resource, locker) -> F
eqt₂(resource, mcrlrecord) -> F
eqt₂(resource, ok) -> F
eqt₂(resource, pending) -> F
eqt₂(resource, release) -> F
eqt₂(resource, request) -> F
eqt₂(resource, resource) -> T
eqt₂(resource, tag) -> F
eqt₂(resource, true) -> F
eqt₂(resource, undefined) -> F
eqt₂(resource, pid₁(N2)) -> F
eqt₂(resource, int₁(N2)) -> F
eqt₂(resource, cons₂(H2, T2)) -> F
eqt₂(resource, tuple₂(H2, T2)) -> F
eqt₂(resource, tuplenil₁(H2)) -> F
eqt₂(tag, nil) -> F
eqt₂(tag, a) -> F
eqt₂(tag, excl) -> F
eqt₂(tag, false) -> F
eqt₂(tag, lock) -> F
eqt₂(tag, locker) -> F
eqt₂(tag, mcrlrecord) -> F
eqt₂(tag, ok) -> F
eqt₂(tag, pending) -> F
eqt₂(tag, release) -> F
eqt₂(tag, request) -> F
eqt₂(tag, resource) -> F
eqt₂(tag, tag) -> T
eqt₂(tag, true) -> F
eqt₂(tag, undefined) -> F
eqt₂(tag, pid₁(N2)) -> F
eqt₂(tag, int₁(N2)) -> F
eqt₂(tag, cons₂(H2, T2)) -> F
eqt₂(tag, tuple₂(H2, T2)) -> F
eqt₂(tag, tuplenil₁(H2)) -> F
eqt₂(true, nil) -> F
eqt₂(true, a) -> F
eqt₂(true, excl) -> F
eqt₂(true, false) -> F
eqt₂(true, lock) -> F
eqt₂(true, locker) -> F
eqt₂(true, mcrlrecord) -> F
eqt₂(true, ok) -> F
eqt₂(true, pending) -> F
eqt₂(true, release) -> F
eqt₂(true, request) -> F
eqt₂(true, resource) -> F
eqt₂(true, tag) -> F
eqt₂(true, true) -> T
eqt₂(true, undefined) -> F
eqt₂(true, pid₁(N2)) -> F
eqt₂(true, int₁(N2)) -> F
eqt₂(true, cons₂(H2, T2)) -> F
eqt₂(true, tuple₂(H2, T2)) -> F
eqt₂(true, tuplenil₁(H2)) -> F
eqt₂(undefined, nil) -> F
eqt₂(undefined, a) -> F
eqt₂(undefined, tuplenil₁(H2)) -> F
eqt₂(pid₁(N1), nil) -> F
eqt₂(pid₁(N1), a) -> F
eqt₂(pid₁(N1), excl) -> F
eqt₂(pid₁(N1), false) -> F
eqt₂(pid₁(N1), lock) -> F
eqt₂(pid₁(N1), locker) -> F
eqt₂(pid₁(N1), mcrlrecord) -> F
eqt₂(pid₁(N1), ok) -> F
eqt₂(pid₁(N1), pending) -> F
eqt₂(pid₁(N1), release) -> F
eqt₂(pid₁(N1), request) -> F
eqt₂(pid₁(N1), resource) -> F
eqt₂(pid₁(N1), tag) -> F
eqt₂(pid₁(N1), true) -> F
eqt₂(pid₁(N1), undefined) -> F
eqt₂(pid₁(N1), pid₁(N2)) -> eqt₂(N1, N2)
eqt₂(pid₁(N1), int₁(N2)) -> F
eqt₂(pid₁(N1), cons₂(H2, T2)) -> F
eqt₂(pid₁(N1), tuple₂(H2, T2)) -> F
eqt₂(pid₁(N1), tuplenil₁(H2)) -> F
eqt₂(int₁(N1), nil) -> F
eqt₂(int₁(N1), a) -> F
eqt₂(int₁(N1), excl) -> F
eqt₂(int₁(N1), false) -> F
eqt₂(int₁(N1), lock) -> F
eqt₂(int₁(N1), locker) -> F
eqt₂(int₁(N1), mcrlrecord) -> F
eqt₂(int₁(N1), ok) -> F
eqt₂(int₁(N1), pending) -> F
eqt₂(int₁(N1), release) -> F
eqt₂(int₁(N1), request) -> F
eqt₂(int₁(N1), resource) -> F
eqt₂(int₁(N1), tag) -> F
eqt₂(int₁(N1), true) -> F
eqt₂(int₁(N1), undefined) -> F
eqt₂(cons₂(H1, T1), resource) -> F
eqt₂(cons₂(H1, T1), tag) -> F
eqt₂(cons₂(H1, T1), true) -> F
eqt₂(cons₂(H1, T1), undefined) -> F
eqt₂(cons₂(H1, T1), pid₁(N2)) -> F
eqt₂(cons₂(H1, T1), int₁(N2)) -> F
eqt₂(cons₂(H1, T1), cons₂(H2, T2)) -> and₂(eqt₂(H1, H2), eqt₂(T1, T2))
eqt₂(cons₂(H1, T1), tuple₂(H2, T2)) -> F
eqt₂(cons₂(H1, T1), tuplenil₁(H2)) -> F
eqt₂(tuple₂(H1, T1), nil) -> F
eqt₂(tuple₂(H1, T1), a) -> F
eqt₂(tuple₂(H1, T1), excl) -> F
eqt₂(tuple₂(H1, T1), false) -> F
eqt₂(tuple₂(H1, T1), lock) -> F
eqt₂(tuple₂(H1, T1), locker) -> F
eqt₂(tuple₂(H1, T1), mcrlrecord) -> F
eqt₂(tuple₂(H1, T1), ok) -> F
eqt₂(tuple₂(H1, T1), pending) -> F
eqt₂(tuple₂(H1, T1), release) -> F
eqt₂(tuple₂(H1, T1), request) -> F
eqt₂(tuple₂(H1, T1), resource) -> F
eqt₂(tuple₂(H1, T1), tag) -> F
eqt₂(tuple₂(H1, T1), true) -> F
eqt₂(tuple₂(H1, T1), undefined) -> F
eqt₂(tuple₂(H1, T1), pid₁(N2)) -> F
eqt₂(tuple₂(H1, T1), int₁(N2)) -> F
eqt₂(tuple₂(H1, T1), cons₂(H2, T2)) -> F
eqt₂(tuple₂(H1, T1), tuple₂(H2, T2)) -> and₂(eqt₂(H1, H2), eqt₂(T1, T2))
eqt₂(tuple₂(H1, T1), tuplenil₁(H2)) -> F
eqt₂(tuplenil₁(H1), nil) -> F
eqt₂(tuplenil₁(H1), a) -> F
eqt₂(tuplenil₁(H1), excl) -> F
eqt₂(tuplenil₁(H1), false) -> F
eqt₂(tuplenil₁(H1), lock) -> F
eqt₂(tuplenil₁(H1), locker) -> F
eqt₂(tuplenil₁(H1), mcrlrecord) -> F
eqt₂(tuplenil₁(H1), ok) -> F
eqt₂(tuplenil₁(H1), pending) -> F
eqt₂(tuplenil₁(H1), release) -> F
eqt₂(tuplenil₁(H1), request) -> F
eqt₂(tuplenil₁(H1), resource) -> F
eqt₂(tuplenil₁(H1), tag) -> F
eqt₂(tuplenil₁(H1), true) -> F
eqt₂(tuplenil₁(H1), undefined) -> F
eqt₂(tuplenil₁(H1), pid₁(N2)) -> F
eqt₂(tuplenil₁(H1), int₁(N2)) -> F
eqt₂(tuplenil₁(H1), cons₂(H2, T2)) -> F
eqt₂(tuplenil₁(H1), tuple₂(H2, T2)) -> F
eqt₂(tuplenil₁(H1), tuplenil₁(H2)) -> eqt₂(H1, H2)
element₂(int₁(s₁(0)), tuplenil₁(T1)) -> T1
element₂(int₁(s₁(0)), tuple₂(T1, T2)) -> T1
element₂(int₁(s₁(s₁(N1))), tuple₂(T1, T2)) -> element₂(int₁(s₁(N1)), T2)
record_new₁(lock) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(undefined, tuple₂(nil, tuplenil₁(nil)))))
record_extract₃(tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2))))), lock, resource) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2)))))
record_update₄(tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(F2))))), lock, pending, NewF) -> tuple₂(mcrlrecord, tuple₂(lock, tuple₂(F0, tuple₂(F1, tuplenil₁(NewF)))))
record_updates₃(Record, Name, nil) -> Record
record_updates₃(Record, Name, cons₂(tuple₂(Field, tuplenil₁(NewF)), Fields)) -> record_updates₃(record_update₄(Record, Name, Field, NewF), Name, Fields)
locker2_map_promote_pending₂(nil, Pending) -> nil
locker2_map_promote_pending₂(cons₂(Lock, Locks), Pending) -> cons₂(locker2_promote_pending₂(Lock, Pending), locker2_map_promote_pending₂(Locks, Pending))
locker2_map_claim_lock₃(nil, Resources, Client) -> nil
locker2_map_claim_lock₃(cons₂(Lock, Locks), Resources, Client) -> cons₂(locker2_claim_lock₃(Lock, Resources, Client), locker2_map_claim_lock₃(Locks, Resources, Client))
locker2_map_add_pending₃(nil, Resources, Client) -> nil
locker2_promote_pending₂(Lock, Client) -> case0₃(Client, Lock, record_extract₃(Lock, lock, pending))
case0₃(Client, Lock, cons₂(Client, Pendings)) -> record_updates₃(Lock, lock, cons₂(tuple₂(excl, tuplenil₁(Client)), cons₂(tuple₂(pending, tuplenil₁(Pendings)), nil)))
case0₃(Client, Lock, MCRLFree0) -> Lock
locker2_remove_pending₂(Lock, Client) -> record_updates₃(Lock, lock, cons₂(tuple₂(pending, tuplenil₁(subtract₂(record_extract₃(Lock, lock, pending), cons₂(Client, nil)))), nil))
locker2_add_pending₃(Lock, Resources, Client) -> case1₄(Client, Resources, Lock, member₂(record_extract₃(Lock, lock, resource), Resources))
case1₄(Client, Resources, Lock, true) -> record_updates₃(Lock, lock, cons₂(tuple₂(pending, tuplenil₁(append₂(record_extract₃(Lock, lock, pending), cons₂(Client, nil)))), nil))
case1₄(Client, Resources, Lock, false) -> Lock
locker2_release_lock₂(Lock, Client) -> case2₃(Client, Lock, gen_modtageq₂(Client, record_extract₃(Lock, lock, excl)))
case2₃(Client, Lock, true) -> record_updates₃(Lock, lock, cons₂(tuple₂(excllock, excl), nil))
case4₃(Client, Lock, MCRLFree1) -> false
locker2_obtainables₂(nil, Client) -> true
locker2_obtainables₂(cons₂(Lock, Locks), Client) -> case5₄(Client, Locks, Lock, member₂(Client, record_extract₃(Lock, lock, pending)))
case5₄(Client, Locks, Lock, true) -> andt₂(locker2_obtainable₂(Lock, Client), locker2_obtainables₂(Locks, Client))
case5₄(Client, Locks, Lock, false) -> locker2_obtainables₂(Locks, Client)
locker2_check_available₂(Resource, nil) -> false
locker2_check_available₂(Resource, cons₂(Lock, Locks)) -> case6₄(Locks, Lock, Resource, equal₂(Resource, record_extract₃(Lock, lock, resource)))
case6₄(Locks, Lock, Resource, true) -> andt₂(equal₂(record_extract₃(Lock, lock, excl), nil), equal₂(record_extract₃(Lock, lock, pending), nil))
case6₄(Locks, Lock, Resource, false) -> locker2_check_available₂(Resource, Locks)
locker2_check_availables₂(nil, Locks) -> true
locker2_check_availables₂(cons₂(Resource, Resources), Locks) -> andt₂(locker2_check_available₂(Resource, Locks), locker2_check_availables₂(Resources, Locks))
locker2_adduniq₂(nil, List) -> List
append₂(cons₂(Head, Tail), List) -> cons₂(Head, append₂(Tail, List))
subtract₂(List, nil) -> List
subtract₂(List, cons₂(Head, Tail)) -> subtract₂(delete₂(Head, List), Tail)
delete₂(E, nil) -> nil
delete₂(E, cons₂(Head, Tail)) -> case8₄(Tail, Head, E, equal₂(E, Head))
case8₄(Tail, Head, E, true) -> Tail
case8₄(Tail, Head, E, false) -> cons₂(Head, delete₂(E, Tail))
gen_tag₁(Pid) -> tuple₂(Pid, tuplenil₁(tag))
gen_modtageq₂(Client1, Client2) -> equal₂(Client1, Client2)
member₂(E, nil) -> false
member₂(E, cons₂(Head, Tail)) -> case9₄(Tail, Head, E, equal₂(E, Head))
case9₄(Tail, Head, E, true) -> true
case9₄(Tail, Head, E, false) -> member₂(E, Tail)
eqs₂(empty, empty) -> T
eqs₂(empty, stack₂(E2, S2)) -> F
eqs₂(stack₂(E1, S1), empty) -> F
eqs₂(stack₂(E1, S1), stack₂(E2, S2)) -> and₂(eqt₂(E1, E2), eqs₂(S1, S2))
pushs₂(E1, S1) -> stack₂(E1, S1)
pops₁(stack₂(E1, S1)) -> S1
tops₁(stack₂(E1, S1)) -> E1
istops₂(E1, empty) -> F
istops₂(E1, stack₂(E2, S1)) -> eqt₂(E1, E2)
eqc₂(nocalls, nocalls) -> T
eqc₂(nocalls, calls₃(E2, S2, CS2)) -> F
eqc₂(calls₃(E1, S1, CS1), nocalls) -> F
eqc₂(calls₃(E1, S1, CS1), calls₃(E2, S2, CS2)) -> and₂(eqt₂(E1, E2), and₂(eqs₂(S1, S2), eqc₂(CS1, CS2)))
push₃(E1, E2, nocalls) -> calls₃(E1, stack₂(E2, empty), nocalls)
push₃(E1, E2, calls₃(E3, S1, CS1)) -> push1₆(E1, E2, E3, S1, CS1, eqt₂(E1, E3))
push1₆(E1, E2, E3, S1, CS1, T) -> calls₃(E3, pushs₂(E2, S1), CS1)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.